= 2, ParameterError( \"Parameter 'k' must","approximate quantile). See Also -------- vDataFrame.aggregate : Computes the vDataFrame","for k in range(len(distinct_elements)): expr += [ \"'{}', {}\".format(str(distinct_elements[k]).replace(\"'\", \"''\"),","# # Modules # # Standard Python Modules import math,","interval size to convert to use to convert the vColumn.","str, nbins: int = 10): \"\"\" --------------------------------------------------------------------------- Computes the Information","\"COALESCE({}, {}({}) OVER (PARTITION BY {}))\".format( \"{}\", fun, \"{}\", \",","-------- vDataFrame[].describe : Computes the vColumn descriptive statistics. \"\"\" check_types([(\"k\",","optional Number of most occurent elements to return. dropna: bool,","columns, method, of, max_cardinality, h, ax=ax, **style_kwds, ) # ---#","[int, float])]) if self.isdate(): return self.apply(func=\"TIMESTAMPADD(SECOND, -({}), {})\".format(x, \"{}\")) else:","mean : Average of the vColumn 'of'. min : Minimum","NULL\".format(self.alias) if (category in (\"None\", None)) else \" WHERE {}","parent=None, catalog: dict = {} ): self.parent, self.alias, self.transformations =","int, optional Number of most occurent elements to return. Returns","name, bandwidth=bandwidth, kernel=kernel, nbins=nbins, xlim=xlim_tmp, store=False, ) try: result =","elements cvar : conditional value at risk dtype : vColumn","str, optional Prefix delimitor of the dummies. drop_first: bool, optional","empty or invalid. max_cardinality: int, optional Maximum number of vColumn","Also -------- vDataFrame.topk : Returns the vColumn most occurent elements.","Parameters ---------- *args / **kwargs Any optional parameter to pass","), print_time_sql=False, ) except: avg, stddev = ( \"AVG({}) OVER","\"method\", method, [ \"auto\", \"mode\", \"0ifnull\", \"mean\", \"avg\", \"median\", \"ffill\",","new_vColumn) self.parent._VERTICAPY_VARIABLES_[\"columns\"] += [name] all_new_features += [name] conj = \"s","float optimal bar width. \"\"\" check_types( [(\"method\", method, [\"sturges\", \"freedman_diaconis\",","else 0 for k in range(len(distinct_elements) - n): name =","BY {} ORDER BY {}\".format( bin_spatial_to_str(self.category(), self.alias), self.alias, self.parent.__genSQL__(), self.alias,","return self.aggregate(func=[\"unique\"]).values[self.alias][0] # ---# def pie( self, method: str =","median) prod : product range : difference between the max","was filled.\".format( self.alias ) warnings.warn(warning_message, Warning) return self.parent if isinstance(val,","whole number cos : trigonometric cosine cosh : hyperbolic cosine","= 0 avg, stddev = self.aggregate([\"avg\", \"std\"]).values[self.alias] if stddev ==","the vColumn Density Plot. Parameters ---------- by: str, optional vColumn","= \"\" if (method in (\"ffill\", \"pad\")) else \" DESC\"","str, optional SQL expression. by: list, optional vColumns used in","= True): \"\"\" --------------------------------------------------------------------------- Slices and transforms the vColumn using","END\" self.apply(func=expr) # ---# def ctype(self): \"\"\" --------------------------------------------------------------------------- Returns the","approximate density function. Increasing this parameter will increase the precision","the merging category when using the 'topk' method. RFmodel_params: dict,","category) parent: vDataFrame, optional Parent of the vColumn. One vDataFrame","return self.transformations[-1][2] # ---# def clip(self, lower=None, upper=None): \"\"\" ---------------------------------------------------------------------------","/ spatial / uuid / undefined Returns ------- str vColumn","return [item for sublist in query_result for item in sublist]","str = \"\" ): \"\"\" --------------------------------------------------------------------------- Aggregates the vColumn using","ALL \".join(query), nbins - 1 ) result = executeSQL( query=query,","of most occurent elements to return. Returns ------- tablesample An","outliers. After normalizing the data (Z-Score), if the absolute value","\"varchar\", \"text\", ) elif self.isnum() and method == \"same_freq\": assert","Modules import verticapy from verticapy.utilities import * from verticapy.toolbox import","executeSQL( \"SELECT {}, MIN({}), MAX({}) FROM {} GROUP BY {}\".format(",": Mean for the numerical and Mode for the categorical","to pass to the geopandas plot function. For more information,","cardinality). See Also -------- vDataFrame.aggregate : Computes the vDataFrame input","trans = (trans, \"varchar\", \"text\") if return_enum_trans: return trans else:",") desc = \"\" if (method in (\"ffill\", \"pad\")) else","vColumns. vDataFrame.eval : Evaluates a customized expression. \"\"\" if isinstance(func,","self.parent.format_colnames(numcol) assert self.parent[numcol].category() in (\"float\", \"int\"), TypeError( \"The column 'numcol'","isinstance(index_stop, int): if index_stop < 0: index_stop += self.parent.shape()[0] limit","in performance. The catalog will be updated when the parent","numerical. See Also -------- vDataFrame[].isbool : Returns True if the","> 1) Returns ------- tablesample An object containing the result.","def value_counts(self, k: int = 30): \"\"\" --------------------------------------------------------------------------- Returns the","= \"SELECT COUNT({}) AS NAs, MIN({}) AS min, APPROXIMATE_PERCENTILE({} USING","[bool]), (\"right\", right, [bool]), ] ) assert self.isnum() or self.isdate(),","included. right: bool, optional How the intervals should be closed.","-------- vDataFrame.add_copy : Creates a copy of the vColumn. \"\"\"","FROM {} WHERE {} IS NOT NULL) VERTICAPY_SUBTABLE {}\".format( self.alias,","\"approx_\" if approx else \"\" return self.aggregate(func=[prefix + \"{}%\".format(x *","1, \"count\": self.parent.shape()[0], \"percent\": 100.0, \"unique\": 2, \"approx_unique\": 2, \"prod\":","the vColumn using 'sem' (standard error of mean). Returns -------","input functions. Parameters ---------- func: list List of the different","null !\".format( self.alias ) warnings.warn(warning_message, Warning) return self elif (n","vDataFrame[].head : Returns the head of the vColumn. vDataFrame[].tail :","an optimized h will be computed. ax: Matplotlib axes object,","optional The axes to plot on. **style_kwds Any optional parameter","other vColumns. Parameters ---------- add_history: bool, optional If set to","({3}{4} USING PARAMETERS percentile = 0.1) AS 'approx_10%', APPROXIMATE_PERCENTILE ({3}{4}","{}, NULL))\".format( \"{}\", by[0], \", \".join( [\"{}, {}\".format(elem[0], elem[1]) for","not in (\"log\", \"mod\", \"pow\", \"round\"): expr = \"{}({})\".format(func.upper(), \"{}\")","using 'kurtosis'. Returns ------- float kurtosis See Also -------- vDataFrame.aggregate","the mode of the vColumn. Returns ------- str/float/int vColumn nth","to use to compute the aggregation. h: int/float/tuple, optional Interval","using a user-defined encoding. vDataFrame[].discretize : Discretizes the vColumn. vDataFrame[].label_encode","''\", \"varchar\", \"text\") else: trans = (\"{} || ''\", \"varchar\",","vColumn will be transformed. Parameters ---------- pat: str Regular expression.","even: CASE ... WHEN vColumn = argv[2 * i] THEN","to True, the intervals will be closed on the right.","\"NULL\", ) for elem in result if elem[1] != None","executeSQL( \"SELECT ZEROIFNULL(SUM(LENGTH({}::varchar))) FROM {}\".format( bin_spatial_to_str(self.category(), self.alias), self.parent.__genSQL__(), ), title=\"Computing","tangent cbrt : cube root ceil : value up to","(pre_comp != None): return pre_comp assert n >= 1, ParameterError(\"Parameter","the vDataFrame memory usage. \"\"\" import sys total = (",") for i in range(len(result)): if result[i][2] == None: pass","= max(2.0 * (vColumn_075 - vColumn_025) / (count) ** (1.0",": Draws the time series. \"\"\" check_types( [ (\"ts\", ts,","of a response. \"\"\" import verticapy.stats as st return self.apply(func=st.decode(str_sql(\"{}\"),","var : variance Other aggregations could work if it is","ParameterError( \"Length of parameter 'breaks' must be greater or equal","[int, float]), (\"nbins\", nbins, [int, float]), ] ) if of:","isinstance(pie_type, str): pie_type = pie_type.lower() check_types( [ (\"method\", method, [str]),","If empty, an optimized h will be computed. ax: Matplotlib","List of the different transformations. \"\"\" # # Special Methods","\"Badr\"] Returns ------- vDataFrame The vDataFrame of the search. See","== \"zscore\": if n == 0: nullifzero = 0 avg,","= { \"index\": [item[0] for item in result], \"count\": [int(item[1])","SUM({}) AS events FROM ({}) x GROUP BY 1\".format( self.alias,","self.alias.replace('\"', \"\") + prefix_sep.replace('\"', \"_\") if not (prefix) else prefix.replace('\"',","The vDataFrame of the search. See Also -------- vDataFrame.isin :","\"{}\")) # ---# def decode(self, *argv): \"\"\" --------------------------------------------------------------------------- Encodes the","# \\/ / / # / / # / /","func 'x -> {}'.\".format( self.alias.replace('\"', \"\"), func.replace(\"{}\", \"x\"), ) )","lower_when = ( \"WHEN {} < {} THEN {} \".format(\"{}\",","use to compute the optimal h. auto : Combination of","input aggregations. \"\"\" return self.quantile(0.5, approx=approx) # ---# def memory_usage(self):","the function's performance can drastically decrease. Returns ------- float quantile","self.parent.shape()[0], self.parent.__genSQL__(), dropna, self.alias, topk, ) result = executeSQL( query,","datetime.date, int, float], ), ( \"end_date\", end_date, [str, datetime.datetime, datetime.date,","based on an aggregation. Parameters ---------- method: str, optional The","else \"topk\", nbins=nbins, k=nbins, new_category=\"Others\", return_enum_trans=True, )[0].replace(\"{}\", self.alias) query =","( self.parent.describe( method=\"numerical\", columns=[self.alias], unique=False ) .transpose() .values[self.alias] ) count,","under the License. # # |_ |~) _ _| _","to normalize.\".format( by[0] ), method=\"fetchall\", ) cmin = \"DECODE({}, {},","changing one of \" \"the parameters ('prefix', 'prefix_sep'), you'll be","the method '{}'.\".format( self.alias, method ) ) else: raise TypeError(\"The","\\ \\ \\ \\-. \\ # \\ \\__| \\ \\_____\\","use a mean encoding\" ) max_floor = len(self.parent[response].transformations) - len(","date like (date, datetime, timestamp...) or numerical. by: str, optional","kernel. kernel: str, optional The method used for the plot.","the vColumn using a user-defined encoding. Parameters ---------- argv: object",") elif self.isnum() and method == \"same_freq\": assert nbins >=","+= [(\"{}\", self.ctype(), self.category())] self.transformations += [ (\"AVG({}) OVER (PARTITION","the following: date / int / float / text /","in query_result for item in sublist] # ---# def div(self,","information, see utilities.tablesample. See Also -------- vDataFrame.iv_woe : Computes the","column of that relation. vColumns simplify several processes with its","{}) {}\".format( self.parent.__genSQL__(), query ) query_result = executeSQL( query=query, title=\"Computing","on numerical / date-like vColumns.\" ) assert len(breaks) >= 2,","vColumn is numerical. \"\"\" return self.category() == \"date\" # ---#","warnings.warn(warning_message, Warning) return self elif method == \"minmax\": if n","f\"A vColumn has already the alias {name}.\\nBy changing the parameter","BY split_value::float\".format( \" UNION ALL \".join(query), nbins - 1 )",": Returns the head of the vColumn. vDataFrame[].tail : Returns","See Also -------- vDataFrame.drop: Drops the input vColumns from the","statistics of a numerical column for each vColumn category. In","Parameters ---------- name: str Name of the copy. Returns -------","kernel: str, optional The method used for the plot. gaussian","the optimal vColumn bar width. Parameters ---------- method: str, optional","start: bool, optional If set to True, the record will","[], parent=None, catalog: dict = {} ): self.parent, self.alias, self.transformations","MAX({}) AS max FROM {}\".format( self.alias, self.alias, self.alias, self.alias, self.alias,","each record of the vColumn. vDataFrame[].str_replace : Replaces the regular","the vColumn {} using the following mapping:{}\".format( self.alias, text_info )","sauv[\"count\"] / self.parent.shape()[0] ) for elem in sauv: if \"top\"","used in the partition. return_trans: bool, optimal If set to",") expr = \"DECODE({}, '{}', 1, 0)\".format( \"{}\", str(distinct_elements[k]).replace(\"'\", \"''\")","vColumn_max = result sturges = max( float(vColumn_max - vColumn_min) /","str / date, optional Input Start Date. For example, time","ceiling. Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].date_part :","self.alias: [store_usage]} ) return store_usage # ---# def str_contains(self, pat:","in self.catalog: total += sys.getsizeof(elem) return total # ---# def","Mode for the categorical vColumns. bfill : Back Propagation of","\"\" if (n == 1) else str(int(n)) if isinstance(top, decimal.Decimal):","cast, self.parent.__genSQL__(), self.parent.__get_last_order_by__(), index, ) return executeSQL( query=query, title=\"Getting the","percent FROM {}{} GROUP BY {} ORDER BY _verticapy_cnt_ DESC","for idx, column in enumerate(columns): param = {\"color\": colors[idx %","vColumn. \"\"\" return self.apply(func=\"ABS({})\") # ---# def add(self, x: float):","( name.replace(\" \", \"_\") .replace(\"/\", \"_\") .replace(\",\", \"_\") .replace(\"'\", \"_\")","unit. For example, it can be 'minute' 'hour'... start: bool,","brings the logic to the data. # # # Modules","{}, ROW_NUMBER() OVER (ORDER BY {}) AS _verticapy_row_nb_ FROM {}",") ) else: if verticapy.options[\"print_info\"]: print(\"Nothing was filled.\") self.transformations =","vColumn {} was deleted from the vDataFrame.\".format(self.alias) ) return parent","an outlier. use_threshold: bool, optional Uses the threshold instead of","the function: x -> x^2 + 2 use \"POWER({}, 2)","\"bfill\", \"backfill\", ], ), (\"expr\", expr, [str]), (\"by\", by, [list]),","= verticapy.options[\"temp_schema\"] if not (schema): schema = \"public\" name =","to sequentialize # data transformation operations, and offers beautiful graphical","this parameter is equal to 0, an optimised interval will","'labels' + 1 or parameter 'labels' must be empty.\" )","the different categories {} to normalize.\".format( by[0] ), method=\"fetchall\", )","round(h, 4) elif h > 0.000001: h = round(h, 6)","def cut( self, breaks: list, labels: list = [], include_lowest:","order_by_ts = \", \".join([quote_ident(column) + desc for column in order_by])","Column.\".format( self.alias, response ) ) if verticapy.options[\"print_info\"]: print(\"The mean encoding","the different transformations. Each transformation must be similar to the","and merge the other into one unique category. h: float,","Returns ------- float var See Also -------- vDataFrame.aggregate : Computes","\"\"\" return self.transformations[-1][1].lower() dtype = ctype # ---# def date_part(self,","{}.\".format(self.alias), method=\"fetchall\", ) return [item for sublist in query_result for","by = self.parent.format_colnames(by) from verticapy.plot import boxplot return boxplot(self, by,","to the length of parameter 'labels' + 1 or parameter","0, 1)\" elif method in (\"mean\", \"avg\", \"median\"): fun =","\"At least 'lower' or 'upper' must have a numerical value\"","optimal bar width. \"\"\" check_types( [(\"method\", method, [\"sturges\", \"freedman_diaconis\", \"fd\",","val): self.__dict__[attr] = val # # Methods # # ---#","------- int vColumn cardinality (or approximate cardinality). See Also --------","(sauv[elem] - sauv[\"min\"]) / ( sauv[\"max\"] - sauv[\"min\"] ) except:","can only have one parent. catalog: dict, optional Catalog where","Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].drop_outliers : Drops","--------------------------------------------------------------------------- Aggregates the vColumn using 'max' (Maximum). Returns ------- float/str","discretization (must be > 1) k: int, optional The integer","0, nbins: int = -1, k: int = 6, new_category:","\"NULL\" self.apply( func=\"(CASE WHEN {} < {} THEN {} WHEN","boolean. See Also -------- vDataFrame[].isdate : Returns True if the","= get_data_types( \"SELECT {} AS apply_test_feature FROM {} WHERE {}","start: int, step: int): \"\"\" --------------------------------------------------------------------------- Slices the vColumn. The","by[0], \", \".join( [ \"{}, {}\".format( \"'{}'\".format(str(elem[0]).replace(\"'\", \"''\")) if elem[0]","1], result[i], result[i - 1], result[i] ) trans += \"","vDataFrame.aggregate : Computes the vDataFrame input aggregations. \"\"\" return self.aggregate([\"aad\"]).values[self.alias][0]","If empty, names will be generated. include_lowest: bool, optional If","hist return hist(self, method, of, max_cardinality, nbins, h, ax=ax, **style_kwds)","__ __ __ __ __ __ __ # /\\ \\","you'll be able to solve this issue.\" ) new_vColumn =","\"\"\" return self.category() in (\"float\", \"int\") # ---# def iv_woe(self,","{}, \"regr_count\": {}, \"regr_intercept\": {}, \"regr_r2\": {}, \"regr_slope\": {}, \"regr_sxx\":","of the copy. Returns ------- vDataFrame self.parent See Also --------","using the Robust Z-Score (median and mad). (x - median)","vColumn. vDataFrame[].tail : Returns the tail of the vColumn. \"\"\"","vColumn using 'product'. Returns ------- float product See Also --------","'numcol' must be a vDataFrame column if the method is","draw the Plot. start_date: str / date, optional Input Start","transformed. Parameters ---------- field: str The field to extract. It","otherwise. Returns ------- bool True if the vColumn is numerical.","\"\", plot_median: bool = False, ax=None, **style_kwds, ): \"\"\" ---------------------------------------------------------------------------","\"\"\" return self.aggregate([\"skewness\"]).values[self.alias][0] skew = skewness # ---# def slice(self,","AS 'approx_90%', MAX({3}{4}) AS max FROM vdf_table\"\"\".format( category, self.alias, self.parent.shape()[0],","\" WHERE {} IS NULL\".format(self.alias) if (category in (\"None\", None))","category when using the 'topk' method. RFmodel_params: dict, optional Dictionary","with One-Hot Encoding. vDataFrame[].label_encode : Encodes the vColumn with Label","isnum(self): \"\"\" --------------------------------------------------------------------------- Returns True if the vColumn is numerical,","categories. Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].decode :","{}{}ELSE {} END)\".format(lower_when, upper_when, \"{}\") self.apply(func=func) return self.parent # ---#","in query_result] index = [\"unique\", \"count\"] + [item[0] for item","({})\".format(\"{}\", x)) # ---# def nlargest(self, n: int = 10):","] ) method = method.lower() self.parent.are_namecols_in(by) by = self.parent.format_colnames(by) nullifzero,","Z-Score (median and mad). (x - median) / (1.4826 *","float], (\"approx\", approx, [bool]))]) prefix = \"approx_\" if approx else","self.alias, self.alias, n ) title = \"Reads {} {} smallest","/ n ** (1 / 3)] sturges : Sturges [CEIL(log2(n))","= 0 all_partition = by if method in [\"ffill\", \"pad\",","1 (1 meaning global outlier). \"\"\" if isinstance(method, str): method","if not (schema): schema = \"public\" tmp_view_name = gen_tmp_name(schema=schema, name=\"view\")","end_date, area, step, ax=ax, **style_kwds, ) # ---# def product(self):","= int(max(math.floor(h), 1)) floor_end = -1 if (self.category() == \"int\")","setting this parameter to False, the function's performance can drastically","vColumn descriptive statistics. \"\"\" return self.describe(method=\"categorical\", max_cardinality=k) # ---# def","__ __ __ __ __ __ # /\\ \\ /","the vColumn using 'min' (Minimum). Returns ------- float/str minimum See","must be greater or equals to 2 in case of","True, alpha: float = 0.05, ): \"\"\" --------------------------------------------------------------------------- Fills the","of the vColumn records. vDataFrame[].extract : Extracts the regular expression","[str]), (\"max_cardinality\", max_cardinality, [int, float]), (\"h\", h, [int, float]), (\"cat_priority\",","One-Hot Encoding algorithm. Parameters ---------- prefix: str, optional Prefix of","has already the alias {new_name}.\\nBy changing the parameter 'new_name', you'll","Drops the vColumn missing values. \"\"\" if isinstance(by, str): by","lower: float, optional Lower bound. upper: float, optional Upper bound.","(method == \"cat_stats\") and (numcol != \"\"): numcol = self.parent.format_colnames(numcol)","mode(self, dropna: bool = False, n: int = 1): \"\"\"","\"zscore\": if n == 0: nullifzero = 0 avg, stddev","--------------------------------------------------------------------------- Aggregates the vColumn using 'std' (Standard Deviation). Returns -------","LAST_VALUE({} IGNORE NULLS) OVER ({} ORDER BY {}))\".format( \"{}\", \"{}\",","WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or","will be trained if the response is numerical (except ints","Parameters ---------- response: str Response vColumn. Returns ------- vDataFrame self.parent","parameter to pass to the Matplotlib functions. Returns ------- ax","Evaluates a customized expression. \"\"\" if isinstance(func, str_sql): func =","bool, optional How the intervals should be closed. If set","--------------------------------------------------------------------------- Drops the vColumn from the vDataFrame. Dropping a vColumn","Also -------- vDataFrame[].date_part : Extracts a specific TS field from","fun == \"MEDIAN\": fun = \"APPROXIMATE_MEDIAN\" query = \"SELECT {},","executeSQL( \"SELECT {} FROM {} LIMIT 1\".format( new_column.format(self.alias), self.parent.__genSQL__() ),","for column in all_cols: try: if (quote_ident(column) in func) or","intervals will be closed on the right. Returns ------- vDataFrame","use_threshold, [bool]), (\"threshold\", threshold, [int, float]), ] ) if use_threshold:","---# def range_plot( self, ts: str, q: tuple = (0.25,","--------------------------------------------------------------------------- Encodes the vColumn using the average of the response","Aggregates the vColumn using an input 'quantile'. Parameters ---------- x:","THEN '{label}'\" ] expr = \"CASE WHEN \" + \"","if (dropna) else \" \" result = executeSQL( \"SELECT {}","model.get_params() try: model.fit(tmp_view_name, [self.alias], response) query = [ \"(SELECT READ_TREE(USING","the # entire data science life cycle, uses a ‘pipeline’","ax kernel = kernel.lower() from verticapy.learn.neighbors import KernelDensity schema =","vColumns. bfill : Back Propagation of the next element (Constant","median). It can also be a cutomized aggregation (ex: AVG(column1)","\" WHEN \".join(conditions) + \" END\" self.apply(func=expr) # ---# def","elif idx == 0: op1, close_l = \"<\", \"]\" if","head of the vColumn. Parameters ---------- limit: int, optional Number","offset = max(0, self.parent.shape()[0] - limit) title = \"Reads {}.\".format(self.alias)","self.parent See Also -------- vDataFrame.fill_outliers : Fills the outliers in","ax Matplotlib axes object See Also -------- vDataFrame.bar : Draws","self.alias ) warnings.warn(warning_message, Warning) return self.parent if isinstance(val, str): val","\"\"\" --------------------------------------------------------------------------- Encodes the vColumn using the average of the","\\ / # \\/ # _ # \\ / _","0.01: h = round(h, 2) elif h > 0.0001: h","instead of moving # data around for processing, VerticaPy brings","the learning and scoring phases. xlim: tuple, optional Set the","elif h > 0.0001: h = round(h, 4) elif h","catalog will be updated when the parent vDataFrame is modified.","elif method == \"0ifnull\": new_column = \"DECODE({}, NULL, 0, 1)\"","except: pass total = int(total) conj = \"s were \"","for vColumns 1 and 2 to be used as categorical","only categorical aggregations during the computation. cat_stats : Computes statistics","[], [] while total < int(float(count / int(nbins))) * int(nbins):","\"\"\" check_types( [ (\"by\", by, [str]), (\"method\", method, [str]), (\"of\",","--------------------------------------------------------------------------- Applies a function to the vColumn. Parameters ---------- func:","NOT NULL GROUP BY {0} ORDER BY COUNT(*)\" \" DESC","add_history: bool = True): \"\"\" --------------------------------------------------------------------------- Drops the vColumn from","Parameters ---------- method: str, optional The describe method. auto :","length: int, unit: str = \"second\", start: bool = True):","after the comma. Parameters ---------- n: int Number of digits","HOUR / ISODOW / ISOWEEK / ISOYEAR / MICROSECONDS /","()) AS pt_events FROM ({}) x\".format( self.alias, query, ) query","self.parent See Also -------- vDataFrame[].apply : Applies a function to","[float, int]), ] ) if by: self.parent.are_namecols_in(by) by = self.parent.format_colnames(by)","result = [elem[0] for elem in result] elif self.isnum() and","\"auto\", h: float = 0, nbins: int = -1, k:","upper and lower outliers by their respective average. null :","See Also -------- vDataFrame[].str_count : Computes the number of matches","): \"\"\" --------------------------------------------------------------------------- Discretizes the vColumn using the input method.","is numerical. See Also -------- vDataFrame[].isbool : Returns True if","the MAX. MAX = MIN !\".format( self.alias ) warnings.warn(warning_message, Warning)","'topk' method. RFmodel_params: dict, optional Dictionary of the Random Forest","\", \".join([quote_ident(column) + desc for column in order_by]) new_column =","------- float optimal bar width. \"\"\" check_types( [(\"method\", method, [\"sturges\",","datetime, timestamp...) or numerical. by: str, optional vColumn to use","use a method in zscore|minmax\" warnings.warn(warning_message, Warning) return self mad,","= len(self.parent[elem].transformations) max_floor -= len(self.transformations) for k in range(max_floor): self.transformations","None: self.catalog[elem] = None elif method == \"robust_zscore\": self.catalog[elem] =","vDataFrame self.parent See Also -------- vDataFrame[].decode : Encodes the vColumn","if elem[1] != None ] ), ) cmax = \"DECODE({},","normalizing the data (Z-Score), if the absolute value of the","feature by evaluating some conditions. vDataFrame[].discretize : Discretizes the vColumn.","with its abstractions. Parameters ---------- alias: str vColumn alias. transformations:","Also -------- vDataFrame[].bar : Draws the Bar Chart of vColumn","= \"SELECT {} AS {}, {} AS ord, {}::int AS","pre_comp store_usage = executeSQL( \"SELECT ZEROIFNULL(SUM(LENGTH({}::varchar))) FROM {}\".format( bin_spatial_to_str(self.category(), self.alias),","--------------------------------------------------------------------------- Applies the absolute value function to the input vColumn.","warning_message = \"The method 'robust_zscore' is available only if the","VERTICAPY_OPTIMAL_H_TABLE\".format( min_date, self.alias, self.alias, self.parent.__genSQL__() ) query = \"SELECT COUNT({})","element (ex: top1 for the mode) topk_percent : kth most","bool = True): \"\"\" --------------------------------------------------------------------------- Slices and transforms the vColumn","str = \"zscore\", by: list = [], return_trans: bool =","Computes the vColumn descriptive statistics. \"\"\" return self.describe(method=\"categorical\", max_cardinality=k) #","n ) title = \"Reads {} {} largest elements.\".format(self.alias, n)","the distinct categories of {}.\".format(self.alias), method=\"fetchall\", ) return [item for","if some specific records are in the vDataFrame. \"\"\" if","FROM {} LIMIT 1\".format( new_column.format(self.alias), self.parent.__genSQL__() ), print_time_sql=False, ) except:","percentile = 0.25) AS 'approx_25%', APPROXIMATE_PERCENTILE ({3}{4} USING PARAMETERS percentile","Freedman Diaconis [2 * IQR / n ** (1 /","- 1], result[i], result[i - 1], result[i] ) trans +=","lower bound quantile(alpha) and as upper bound quantile(1-alpha) if 'use_threshold'","expr = [\"DECODE({}\"] text_info = \"\\n\" for k in range(len(distinct_elements)):","to the vColumn {} using the following mapping:{}\".format( self.alias, text_info","Interval width of the vColumns 1 and 2 bars. It","\"\"\" --------------------------------------------------------------------------- Returns the distinct categories of the vColumn. Returns","'order_by' must be a list of at least one element","'{label}'\" ] expr = \"CASE WHEN \" + \" WHEN","2) + 2)), 1e-99, ) fd = max(2.0 * (vColumn_075","datetime.date] = \"\", end_date: Union[str, datetime.datetime, datetime.date] = \"\", plot_median:","the vColumn \" \"or simply because of ambiguous columns naming.\\nBy","step, ax=ax, **style_kwds, ) # ---# def product(self): \"\"\" ---------------------------------------------------------------------------","occurent element. See Also -------- vDataFrame.aggregate : Computes the vDataFrame","-------- vDataFrame.fill_outliers : Fills the outliers in the vColumn. vDataFrame.outliers","following mapping:{}\".format( self.alias, text_info ) ) return self.parent # ---#","dropna, [bool]), (\"n\", n, [int, float])]) if n == 1:","elements.\".format(n, self.alias) return to_tablesample(query, title=title) # ---# def numh(self, method:","if index < 0: index += self.parent.shape()[0] query = \"SELECT","bool, optional If set to True, the lowest element of","{} to normalize.\".format( by[0] ), method=\"fetchall\", ) cmin = \"DECODE({},","\"\", area: bool = False, step: bool = False, ax=None,","doesn't allow slicing having steps different than 1.\" ) index_stop","for item in result], \"count\": [int(item[1]) for item in result],","h, floor_end ), \"varchar\", \"text\", ) else: trans = (\"FLOOR({})","_repr_html_(self): return self.head(limit=verticapy.options[\"max_rows\"])._repr_html_() # ---# def __setattr__(self, attr, val): self.__dict__[attr]","specific vColumn. \"\"\" return self.parent.aggregate(func=func, columns=[self.alias]).transpose() agg = aggregate #","sine sqrt : arithmetic square root tan : trigonometric tangent","(\"nbins\", nbins, [float, int]), ] ) if by: self.parent.are_namecols_in(by) by","else \"\" ) upper_when = ( \"WHEN {} > {}","occurent element. Parameters ---------- dropna: bool, optional If set to","using the Z-Score (avg and std). (x - avg) /","6, new_category: str = \"Others\", RFmodel_params: dict = {}, response:","- {}) / {}({})\".format( self.alias, avg, \"NULLIFZERO\" if (nullifzero) else","--------------------------------------------------------------------------- Python object which that stores all user transformations. If","input aggregations. \"\"\" return self.aggregate([\"min\"]).values[self.alias][0] # ---# def mode(self, dropna:","ax = self.parent.search( \"{} = '{}'\".format(self.parent[by].alias, column) )[self.alias].density( bandwidth=bandwidth, kernel=kernel,","specific TS field from the vColumn. \"\"\" check_types( [ (\"length\",","-------- vDataFrame.eval : Evaluates a customized expression. \"\"\" check_types([(\"name\", name,","\"min\", \"max\"]) index = result.values[\"index\"] result = result.values[self.alias] elif (method","see utilities.tablesample. See Also -------- vDataFrame.iv_woe : Computes the Information","colors = gen_colors() if not xlim: xmin = self.min() xmax","-------- vDataFrame[].str_count : Computes the number of matches for the","(1 meaning global outlier). \"\"\" if isinstance(method, str): method =",": Draws the Bar Chart of the input vColumns based","Returns the tail of the vColumn. Parameters ---------- limit: int,","---# def isdate(self): \"\"\" --------------------------------------------------------------------------- Returns True if the vColumn","round(h, 2) elif h > 0.0001: h = round(h, 4)","was discretized.\".format(self.alias) ) return self.parent # ---# def distinct(self, **kwargs):","cat_priority: list = [], ax=None, **style_kwds, ): \"\"\" --------------------------------------------------------------------------- Draws","Example: Write {\"n_estimators\": 20, \"max_depth\": 10} to train a Random","h = self.numh() else: h = (self.max() - self.min()) *","to False else the lower and upper ZScores. threshold: float,","/ binary / spatial / uuid / undefined Returns -------",": Returns the n smallest elements in the vColumn. \"\"\"","method: str, optional Method to use to normalize. zscore :","str, optional Response vColumn when method is set to 'smart'.","of the vColumn. Parameters ---------- limit: int, optional Number of","ORDER BY verticapy_agg DESC\".format( self.alias, bin_spatial_to_str(self.category(), self.alias), self.alias, kwargs[\"agg\"], self.parent.__genSQL__(),","self.apply( func=\"(CASE WHEN ({} BETWEEN {} AND {}) THEN {}","GROUP BY 1 ORDER BY 2 DESC LIMIT {}) VERTICAPY_SUBTABLE","return self.category() == \"date\" # ---# def isin(self, val: list,","else: xlim_tmp = [] model = KernelDensity( name, bandwidth=bandwidth, kernel=kernel,","self.parent.__add_to_history__( \"[AsType]: The vColumn {} was converted to {}.\".format( self.alias,","vColumn. \"\"\" return self.iloc(limit=limit, offset=-1) # ---# def topk(self, k:","\"{}\", result[i - 1], result[i], result[i - 1], result[i] )","( \"method\", method, [ \"auto\", \"mode\", \"0ifnull\", \"mean\", \"avg\", \"median\",","READ_TREE(USING PARAMETERS model_name = '{}', tree_id = {}, format =","to the next whole number ln : natural logarithm log","vDataFrame input aggregations. \"\"\" return self.aggregate([\"stddev\"]).values[self.alias][0] stddev = std #","= True, alpha: float = 0.05 ): \"\"\" --------------------------------------------------------------------------- Drops",": Returns the vColumn database type. \"\"\" return self.transformations[-1][2] #","\"\"\" --------------------------------------------------------------------------- Computes the optimal vColumn bar width. Parameters ----------","bin_spatial_to_str(self.category()), \", \".join( [ \"'{}'\".format(str(elem).replace(\"'\", \"''\")) for elem in distinct","elem in result if elem[1] != None ] ), )","0: if nbins <= 0: h = self.numh() else: h","def __init__( self, alias: str, transformations: list = [], parent=None,","\"sign\", \"sin\", \"sinh\", \"sqrt\", \"tan\", \"tanh\", ], ), (\"x\", x,","correlated features. use_numbers_as_suffix: bool, optional Uses numbers as suffix instead","the different records. For example, to check if Badr and","if 'use_threshold' is set to False else the lower and","---# def mean_encode(self, response: str): \"\"\" --------------------------------------------------------------------------- Encodes the vColumn","or (upper != None), ParameterError( \"At least 'lower' or 'upper'","\"{}({}, {})\".format(func.upper(), \"{}\", x) return self.apply(func=expr) # ---# def astype(self,","optional The vColumn to use to compute the aggregation. h:","data using the input expression. \"\"\" self.parent.filter(\"{} IS NOT NULL\".format(self.alias))","\"median\") or isinstance(val, float): category, ctype = \"float\", \"float\" elif","optional Number of elements to display. Returns ------- tablesample An","you'll be able to solve this issue.\" ) self.add_copy(new_name) parent","--------------------------------------------------------------------------- Normalizes the input vColumns using the input method. Parameters","impute the vColumn. method: dict, optional Method to use to","a response. \"\"\" check_types( [ (\"prefix\", prefix, [str]), (\"prefix_sep\", prefix_sep,","), (\"return_enum_trans\", return_enum_trans, [bool]), ] ) method = method.lower() if","element of the list will be included. right: bool, optional","data (Z-Score), if the absolute value of the record is",": Encodes the vColumn with user defined Encoding. vDataFrame[].discretize :","nbins: int, optional Maximum number of nbins used for the","---# def rename(self, new_name: str): \"\"\" --------------------------------------------------------------------------- Renames the vColumn","value: str = \"\"): \"\"\" --------------------------------------------------------------------------- Replaces the regular expression","Sets the method to 'numerical' if the vColumn is numerical","close_l, close_r = \"<=\", \"<\", \"[\", \"[\" if idx ==","method == \"minmax\": self.catalog[\"min\"] = 0 self.catalog[\"max\"] = 1 self.parent.__add_to_history__(","self.parent.format_colnames(of) from verticapy.plot import hist return hist(self, method, of, max_cardinality,","vColumn. One vDataFrame can have multiple children vColumns whereas one","total # ---# def min(self): \"\"\" --------------------------------------------------------------------------- Aggregates the vColumn","Encodes the vColumn with user defined Encoding. vDataFrame[].get_dummies : Encodes","the mean encoding of a response. \"\"\" if self.category() in","Returns the n smallest elements in the vColumn. Parameters ----------","vColumn most occurent elements. \"\"\" if \"agg\" not in kwargs:","axes object \"\"\" columns = [self.alias] check = True if","sign sin : trigonometric sine sinh : hyperbolic sine sqrt","data stored in Vertica, taking advantage Vertica’s # speed and","Parameters ---------- dropna: bool, optional If set to True, NULL","return trans else: self.transformations += [trans] sauv = {} for","for elem in self.transformations] total = self.count() if method not","be empty.\" ) conditions, column = [], self.alias for idx","of the dummies. prefix_sep: str, optional Prefix delimitor of the","optional Lower bound. upper: float, optional Upper bound. Returns -------","the vColumn element.\", method=\"fetchfirstelem\", ) else: return getattr(self, index) #","vDataFrame.aggregate : Computes the vDataFrame input aggregations. \"\"\" check_types([(\"dropna\", dropna,","expected store usage (unit: b). Returns ------- int vColumn expected","_verticapy_row_nb_ IN ({})\".format( \", \".join([\"1\"] + nth_elems + [str(count)]) )","- index_start if limit <= 0: limit = 0 limit","to True, the lowest element of the list will be","= self.parent force_columns = [ column for column in self.parent._VERTICAPY_VARIABLES_[\"columns\"]","max_floor = len(self.parent[response].transformations) - len( self.transformations ) for k in","return self.iloc(limit=limit, offset=-1) # ---# def topk(self, k: int =","< {}\".format( self.alias, result[\"avg\"][0], result[\"std\"][0], threshold ) ) else: p_alpha,","ORDER BY 2 DESC LIMIT {}) VERTICAPY_SUBTABLE ORDER BY split_value::float\".format(","'alpha' parameter. alpha: float, optional Number representing the outliers threshold.","(or approximate cardinality). See Also -------- vDataFrame.aggregate : Computes the","learning features. It supports the # entire data science life","name[1:-1], new_vColumn) self.parent._VERTICAPY_VARIABLES_[\"columns\"] += [name] self.parent.__add_to_history__( \"[Add Copy]: A copy","of discretization using the method 'smart'.\" ) self.parent.are_namecols_in(response) response =","discretized.\".format(self.alias) ) return self.parent # ---# def distinct(self, **kwargs): \"\"\"","vDataFrame self.parent See Also -------- vDataFrame.case_when : Creates a new","ValueError(\"Division by 0 is forbidden !\") return self.apply(func=\"{} / ({})\".format(\"{}\",","with {} as Response Column.\".format( self.alias, response ) ) if","value function to the input vColumn. Returns ------- vDataFrame self.parent","index < 0: index += self.parent.shape()[0] query = \"SELECT {}{}","str(distinct_elements[k]).replace('\"', \"_\") ) ) name = ( name.replace(\" \", \"_\")","'topk' method. new_category: str, optional The name of the merging","non-missing elements cvar : conditional value at risk dtype :","return self.aggregate([\"sem\"]).values[self.alias][0] # ---# def skewness(self): \"\"\" --------------------------------------------------------------------------- Aggregates the","def str_contains(self, pat: str): \"\"\" --------------------------------------------------------------------------- Verifies if the regular","new_vColumn) self.parent._VERTICAPY_VARIABLES_[\"columns\"] += [name] self.parent.__add_to_history__( \"[Add Copy]: A copy of","of the vColumn 'of'. q% : q Quantile of the","], ), (\"expr\", expr, [str]), (\"by\", by, [list]), (\"order_by\", order_by,","TS. start_date: str / date, optional Input Start Date. For","self.alias, dtype, self.alias, self.parent.__genSQL__(), self.alias ) executeSQL(query, title=\"Testing the Type","{} for elem in self.catalog: sauv[elem] = self.catalog[elem] self.parent.__update_catalog__(erase=True, columns=[self.alias])","the 'topk' method. new_category: str, optional The name of the","\"\"\" --------------------------------------------------------------------------- Verifies if the regular expression is in each","elem in self.catalog: sauv[elem] = self.catalog[elem] self.parent.__update_catalog__(erase=True, columns=[self.alias]) total =","vColumn using 'skewness'. Returns ------- float skewness See Also --------","\"\"\" return self.parent.aggregate(func=func, columns=[self.alias]).transpose() agg = aggregate # ---# def","title = \"Reads {} {} largest elements.\".format(self.alias, n) return to_tablesample(query,","Replaces the regular expression matches in each of the vColumn","{} AND {})\".format(self.alias, p_alpha, p_1_alpha) ) return self.parent # ---#","optional If set to True, the Median will be drawn.","1) and (self.parent[by[0]].nunique() < 50): try: if fun == \"MEDIAN\":","to normalize. zscore : Normalization using the Z-Score (avg and","|_) # \\/ (/_| | |(_(_|| \\/ # / #","float/str median See Also -------- vDataFrame.aggregate : Computes the vDataFrame","of parameter breaks must be equal to the length of","assert k >= 2, ParameterError( \"Parameter 'k' must be greater","\"regr_avgx\": {}, \"regr_avgy\": {}, \"regr_count\": {}, \"regr_intercept\": {}, \"regr_r2\": {},","else: query = \"SELECT {} FROM (SELECT {} AS {},","bool, optional If set to True, NULL values will not","vColumn. The aggregations used are the median and two input","values will not be considered during the computation. Returns -------",") warnings.warn(warning_message, Warning) else: distinct_elements = self.distinct() expr = [\"DECODE({}\"]","= self.parent.format_colnames(response) assert self.parent[response].isnum(), TypeError( \"The response column must be","rule. Parameters ---------- length: int Slice size. unit: str, optional","to the data. # # # Modules # # Standard","splits when 'method' is set to 'smart'. A RF Regressor","bool = False, ax=None, **style_kwds, ): \"\"\" --------------------------------------------------------------------------- Draws the","cbrt : cube root ceil : value up to the","[bool]), (\"h\", h, [int, float]), (\"response\", response, [str]), (\"nbins\", nbins,","MIN({}) AS min, APPROXIMATE_PERCENTILE({} USING PARAMETERS percentile = 0.25) AS","-------- vDataFrame[].describe : Computes the vColumn descriptive statistics. \"\"\" return","in by]) ) if (by) else \"\" ) order_by_ts =","equal to 2.\" ) assert len(breaks) == len(labels) + 1","] expr = \"CASE WHEN \" + \" WHEN \".join(conditions)",") result = [elem[0] for elem in result] elif self.isnum()","use to partition the data. bandwidth: float, optional The bandwidth","0\".format( func.replace(\"{}\", self.alias), self.parent.__genSQL__(), self.alias, ), \"apply_test_feature\", ) category =","(use_numbers_as_suffix) else '\"{}{}\"'.format( prefix, str(distinct_elements[k]).replace('\"', \"_\") ) ) name =","iqr : interquartile range kurtosis : kurtosis jb : Jarque-Bera","pre_comp assert self.isnum() or self.isdate(), ParameterError( \"numh is only available","str = \"\", max_cardinality: int = 6, h: float =","\"VERTICAPY_NOT_PRECOMPUTED\": return pre_comp store_usage = executeSQL( \"SELECT ZEROIFNULL(SUM(LENGTH({}::varchar))) FROM {}\".format(","vColumn. vDataFrame[].label_encode : Encodes the vColumn with Label Encoding. vDataFrame[].mean_encode","self.parent.__genSQL__(), query ) query_result = executeSQL( query=query, title=\"Computing the descriptive","def iloc(self, limit: int = 5, offset: int = 0):","if (isinstance(lower, (float, int))) else \"\" ) upper_when = (","title=\"Getting the vColumn element.\", method=\"fetchfirstelem\", ) else: return getattr(self, index)","), \"MIN({}) OVER (PARTITION BY {})\".format( self.alias, \", \".join(by) ),","input vColumn based on an aggregation. Parameters ---------- by: str,","of the vColumn 'of'. min : Minimum of the vColumn","increase the precision but will also increase the time of","True if len(args) > 0: column = args[0] elif \"column\"","# ---# def add(self, x: float): \"\"\" --------------------------------------------------------------------------- Adds the","else: h = (self.max() - self.min()) * 1.01 / nbins","{} using the MIN and the MAX. MAX = MIN","is numerical or of type date like. Optimized h will","(self.category() == \"float\"): trans = ( \"'[' || FLOOR({} /","- pt_events) * ZEROIFNULL(LN(pt_non_events / NULLIFZERO(pt_events))) END AS iv FROM","BETWEEN {} AND {} THEN '[{};{}]' \".format( \"{}\", result[i -","\"VERTICAPY_NOT_PRECOMPUTED\": return pre_comp assert self.isnum() or self.isdate(), ParameterError( \"numh is","pass self.parent.__add_to_history__( \"[Discretize]: The vColumn {} was discretized.\".format(self.alias) ) return","lesser than November 1993 the 3rd. end_date: str / date,","# ---# def __getitem__(self, index): if isinstance(index, slice): assert index.step","!= None), ParameterError( \"At least 'lower' or 'upper' must have","used to compute the best splits when 'method' is set","(method != \"cat_stats\") or (numcol), ParameterError( \"The parameter 'numcol' must","x GROUP BY 1\".format( self.alias, y, y, query, ) query","and mad). (x - median) / (1.4826 * mad) minmax","= \"Normalize doesn't work on booleans\".format(self.alias) warnings.warn(warning_message, Warning) elif self.isnum():","median : median min : minimum mode : most occurent","places sign : arithmetic sign sin : trigonometric sine sinh","\"COALESCE({}, DECODE({}, {}, NULL))\".format( \"{}\", by[0], \", \".join( [\"{}, {}\".format(elem[0],","()) AS pt_non_events, events / NULLIFZERO(SUM(events) OVER ()) AS pt_events","the vColumn with One-Hot Encoding. vDataFrame[].label_encode : Encodes the vColumn","vColumn is numerical. See Also -------- vDataFrame[].isbool : Returns True","if \"count\" in sauv: self.catalog[\"count\"] = int(sauv[\"count\"]) + total self.catalog[\"percent\"]","float]), ( \"method\", method, [\"auto\", \"smart\", \"same_width\", \"same_freq\", \"topk\"], ),","prefix, str(distinct_elements[k]).replace('\"', \"_\") ) ) assert not (self.parent.is_colname_in(name)), NameError( f\"A","---------- ts: str TS (Time Series) vColumn to use to","[tuple]), ( \"start_date\", start_date, [str, datetime.datetime, datetime.date, int, float], ),","statistical aggregations: min, max, median, unique... depending on the input","result = self.aggregate(func=[\"std\", \"avg\"]).transpose().values p_alpha, p_1_alpha = ( -threshold *","\"int\") # ---# def iv_woe(self, y: str, nbins: int =","time series rule. \"\"\" return self.apply(func=\"DATE_PART('{}', {})\".format(field, \"{}\")) # ---#","{}.\".format(self.alias) tail = to_tablesample( \"SELECT {} AS {} FROM {}{}","start_date, end_date, plot_median, ax=ax, **style_kwds, ) # ---# def rename(self,","in the final generated SQL code. Note: Dropping a vColumn",") return self.parent one_hot_encode = get_dummies # ---# def head(self,","/ / / # \\ / / / # \\_______/","pie_type: str, optional The type of pie chart. auto :","else \"\" if index < 0: index += self.parent.shape()[0] query","# | \\/ / / / # |______ / /","display. Returns ------- tablesample An object containing the result. For","the histogram of the vColumn based on an aggregation. Parameters","of the vDataFrame parent and do not apply it. This","delattr(self.parent, self.alias) except: self.parent._VERTICAPY_VARIABLES_[\"exclude_columns\"] += [self.alias] if add_history: self.parent.__add_to_history__( \"[Drop]:","bool True if the vColumn is boolean. See Also --------","code. Note: Dropping a vColumn can make the vDataFrame \"heavier\"","---------- val: list List of the different records. For example,","False otherwise. Returns ------- bool True if the vColumn is","of points to use to evaluate the approximate density function.","parameter to pass to the geopandas plot function. For more","of the ceiling. Returns ------- vDataFrame self.parent See Also --------","\"numh is only available on type numeric|date\" ) if self.isnum():","max_cardinality + 1) query = \"WITH vdf_table AS (SELECT *","This parameter is used for testing purpose. Returns ------- vDataFrame",": Maximum of the vColumn 'of'. sum : Sum of","# _ # \\ / _ __|_. _ _ |_)","= \"<\", \"<=\", \"]\", \"]\" else: op1, op2, close_l, close_r","method: str = \"density\", of: str = \"\", max_cardinality: int","when method is set to 'smart'. return_enum_trans: bool, optional Returns",">= 2, ParameterError( \"Parameter 'k' must be greater or equals","optional vColumn to use to partition the data. bandwidth: float,","compute the Equal Frequency discretization\" ) total, query, nth_elems =","verticapy.plot import pie return pie( self, method, of, max_cardinality, h,","and Mode for the categorical vColumns. bfill : Back Propagation","str): \"\"\" --------------------------------------------------------------------------- Extracts the regular expression in each record","\"''\")) if elem[0] != None else \"NULL\", elem[1] if elem[1]","order_by]) new_column = \"COALESCE({}, LAST_VALUE({} IGNORE NULLS) OVER ({} ORDER","= self.parent.get_columns(), 0 for column in all_cols: try: if (quote_ident(column)","\"float\") ] self.parent.__update_catalog__(erase=True, columns=[self.alias]) self.parent.__add_to_history__( \"[Mean Encode]: The vColumn {}","of the vColumn. \"\"\" return self.iloc(limit=limit) # ---# def hist(","the input vColumn. \"\"\" check_types( [ (\"breaks\", breaks, [list]), (\"labels\",","if the vDataFrame has been transformed multiple times, so it's","\"\"\" check_types([(\"x\", x, [int, float])]) assert x != 0, ValueError(\"Division","can be the result of using previously the method on","else \"\" return self.aggregate(func=[prefix + \"{}%\".format(x * 100)]).values[self.alias][ 0 ]","= self.parent.format_colnames(column) columns += [column] if not (\"cmap\" in kwargs):","attr, val): self.__dict__[attr] = val # # Methods # #","and do not apply it. This parameter is very useful","to compute the aggregation. max_cardinality: int, optional Maximum number of","query = \"SELECT * FROM {} WHERE {} IS NOT","\"SELECT {}, {} FROM {} LIMIT 1\".format( avg, stddev, self.parent.__genSQL__()","self.catalog[\"max\"] = 1 self.parent.__add_to_history__( \"[Normalize]: The vColumn '{}' was normalized","--------------------------------------------------------------------------- Aggregates the vColumn using 'var' (Variance). Returns ------- float","- limit) title = \"Reads {}.\".format(self.alias) tail = to_tablesample( \"SELECT","of the vColumn. vDataFrame[].tail : Returns the tail of the","method, [str]), (\"of\", of, [str]), (\"max_cardinality\", max_cardinality, [int, float]), (\"nbins\",","optional The integer k of the 'topk' method. new_category: str,","/ QUARTER / SECOND / TIME ZONE / TIMEZONE_HOUR /","schema = \"public\" tmp_view_name = gen_tmp_name(schema=schema, name=\"view\") tmp_model_name = gen_tmp_name(schema=schema,","1) else \"LIMIT {}\".format(k) dropna = \" WHERE {} IS","use to partition the data. method: str, optional The method","self.parent.__genSQL__() ) p_alpha, p_1_alpha = executeSQL( query=query, title=\"Computing the quantiles","cos : trigonometric cosine cosh : hyperbolic cosine cot :","aggregate the data. count : Number of elements. density :","\"Parameter 'response' can not be empty in case of discretization","\\ \\ \\'/ \\ \\ \\____ \\ \\ \\/\\ \\","the time of the learning and scoring phases. xlim: tuple,","DESC {}\".format( bin_spatial_to_str(self.category(), self.alias), self.alias, self.parent.shape()[0], self.parent.__genSQL__(), dropna, self.alias, topk,","bin_spatial_to_str(self.category(), self.alias), self.alias, kwargs[\"agg\"], self.parent.__genSQL__(), self.alias, ) query_result = executeSQL(","AS _verticapy_row_nb_ FROM {} WHERE {} IS NOT NULL) VERTICAPY_SUBTABLE","vDataFrame[].extract : Extracts the regular expression in each record of","= False, n: int = 1): \"\"\" --------------------------------------------------------------------------- Returns the","bar(self, method, of, max_cardinality, nbins, h, ax=ax, **style_kwds) # ---#","of the mean skewness : skewness sum : sum std","DESC LIMIT {}\".format( self.parent.__genSQL__(), self.alias, self.alias, n ) title =","vDataFrame. Parameters ---------- name: str Name of the copy. Returns","Also -------- vDataFrame.boxplot : Draws the Box Plot of the","sauv: if \"top\" in elem: if \"percent\" in elem: self.catalog[elem]","is boolean, False otherwise. Returns ------- bool True if the","element). 0ifnull : 0 when the vColumn is null, 1","List of the different aggregation. aad : average absolute deviation","[(\"{}\", self.ctype(), self.category())] self.transformations += [(func, ctype, category)] self.parent.__update_catalog__(erase=True, columns=[self.alias])","if the vColumn is boolean. vDataFrame[].isdate : Returns True if","x, [int, float])]) return self.apply(func=\"{} * ({})\".format(\"{}\", x)) # ---#","only have one parent. catalog: dict, optional Catalog where each","\"<=\", \"[\" elif idx == 0: op1, close_l = \"<\",","Start of the slicing. step: int Size of the slicing.","mad(self): \"\"\" --------------------------------------------------------------------------- Aggregates the vColumn using 'mad' (median absolute","---# def __len__(self): return int(self.count()) # ---# def __nonzero__(self): return","jb : Jarque-Bera index mad : median absolute deviation max",") return parent # ---# def drop_outliers( self, threshold: float","natural logarithm log : logarithm log10 : base 10 logarithm","self.aggregate([\"avg\"]).values[self.alias][0] mean = avg # ---# def bar( self, method:","= \"COALESCE({}, '{}')\".format(\"{}\", val) elif expr: new_column = \"COALESCE({}, {})\".format(\"{}\",","{} IS NOT NULL \".format(self.alias) if (dropna) else \" \"","self.parent.__genSQL__(), where, self.alias, n ), title=\"Computing the mode.\", method=\"fetchall\", )","std). (x - avg) / std robust_zscore : Normalization using","index.start if not (isinstance(index_start, int)): index_start = 0 if index_start","executeSQL( \"SELECT {}, AVG({}), STDDEV({}) FROM {} GROUP BY {}\".format(","with a user-specified rule. Parameters ---------- val: int/float/str, optional Value","Returns the vColumn expected store usage (unit: b). Returns -------","\\/ # _ # \\ / _ __|_. _ _","Computes the vDataFrame input aggregations. \"\"\" return self.aggregate([\"sum\"]).values[self.alias][0] # ---#","= 0 THEN 0 ELSE (pt_non_events - pt_events) * ZEROIFNULL(LN(pt_non_events","method, of, max_cardinality, h, donut, rose, ax=None, **style_kwds, ) #","[int])]) self.parent.are_namecols_in(y) y = self.parent.format_colnames(y) assert self.parent[y].nunique() == 2, TypeError(","where = \" WHERE {} IS NOT NULL \".format(self.alias) if","vColumn can make the vDataFrame \"heavier\" if it is used","{} 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)","\"\"\" --------------------------------------------------------------------------- Fills the vColumns outliers using the input method.",") if by: self.parent.are_namecols_in(by) by = self.parent.format_colnames(by) columns = [self.alias,","Drops the input vColumns from the vDataFrame. \"\"\" check_types([(\"add_history\", add_history,","str New type. Returns ------- vDataFrame self.parent See Also --------","float]), (\"h\", h, [int, float]), (\"cat_priority\", cat_priority, [list]), ] )","---# def describe( self, method: str = \"auto\", max_cardinality: int","the vColumn using 'var' (Variance). Returns ------- float var See","index_stop < 0: index_stop += self.parent.shape()[0] limit = index_stop -","------- float skewness See Also -------- vDataFrame.aggregate : Computes the","--------------------------------------------------------------------------- Returns the k most occurent elements and their distributions","/ / # \\ / / / # \\_______/ /","return self.aggregate([\"skewness\"]).values[self.alias][0] skew = skewness # ---# def slice(self, length:","See Also -------- vDataFrame.analytic : Adds a new vColumn to","copy_trans] raise QueryError(\"{}\\nAn Error happened during the filling.\".format(e)) if total","/ std robust_zscore : Normalization using the Robust Z-Score (median","than the threshold it will be considered as an outlier.","x: float): \"\"\" --------------------------------------------------------------------------- Multiplies the vColumn by the input","\"categorical\", \"cat_stats\"]), (\"max_cardinality\", max_cardinality, [int, float]), (\"numcol\", numcol, [str]), ]","Also -------- vDataFrame.astype : Converts the vColumns to the input","] ) if of: self.parent.are_namecols_in(of) of = self.parent.format_colnames(of) from verticapy.plot",") ) return self.parent except Exception as e: raise QueryError(","\"\", start_date: Union[str, datetime.datetime, datetime.date] = \"\", end_date: Union[str, datetime.datetime,","for item in result], \"percent\": [float(round(item[2], 3)) for item in","not (method == \"categorical\")) or ( method == \"is_numeric\" ):","different aggregation. aad : average absolute deviation approx_unique : approximative","the vColumn with Label Encoding. vDataFrame[].mean_encode : Encodes the vColumn","\"\"\" --------------------------------------------------------------------------- Returns True if the vColumn is numerical, False","optimized number of nbins will be computed. h: float, optional","Maximum number of the vColumn distinct elements to be used","mad), \"float\", \"float\", ) ] else: warning_message = \"Can not","self.parent.are_namecols_in(column) column = self.parent.format_colnames(column) columns += [column] if not (\"cmap\"","---# def distinct(self, **kwargs): \"\"\" --------------------------------------------------------------------------- Returns the distinct categories","types to varchar. same_freq : Computes bins with the same","< 0: offset = max(0, self.parent.shape()[0] - limit) title =","{}) OVER () FROM {} LIMIT 1\".format( alpha, self.alias, alpha,","self.parent[numcol].category() in (\"float\", \"int\"), TypeError( \"The column 'numcol' must be","import ts_plot return ts_plot( self, ts, by, start_date, end_date, area,","the data (Z-Score), if the absolute value of the record","\\/_/ \\/_/ \\/_/ \\/_/ # # # ---# class vColumn(str_sql):","is greater than November 1993 the 3rd. plot_median: bool, optional","solve this issue.\" ) self.add_copy(new_name) parent = self.drop(add_history=False) parent.__add_to_history__( \"[Rename]:","be converted to {}\".format( e, self.alias, dtype ) ) #","Usage of the vColumn {}.\".format(self.alias), method=\"fetchfirstelem\", ) self.parent.__update_catalog__( {\"index\": [\"store_usage\"],","by: str = \"\", bandwidth: float = 1.0, kernel: str","vColumn_max = ( result[0], result[3], result[4], result[6], result[7], ) elif","Fills the outliers in the vColumn. vDataFrame.outliers : Adds a","\", \".join(by) ), ) else: avg, stddev = ( \"AVG({})","value to a specified number of decimal places sign :","APPROXIMATE_PERCENTILE ({3}{4} USING PARAMETERS percentile = 0.9) AS 'approx_90%', MAX({3}{4})","picked or computed) nbins: int, optional Number of nbins. If","or numerical. by: str, optional vColumn to use to partition","next whole number ln : natural logarithm log : logarithm","in range(len(breaks) - 1): first_elem, second_elem = breaks[idx], breaks[idx +","# ---# def nsmallest(self, n: int = 10): \"\"\" ---------------------------------------------------------------------------","categories will be filtered. ax: Matplotlib axes object, optional The","to aggregate the data. count : Number of elements. density","above. The idea is simple: instead of moving # data","not normalize {} using a Z-Score - The Standard Deviation","method == \"zscore\": self.catalog[\"mean\"] = 0 self.catalog[\"std\"] = 1 elif","\"mode\" total = self.count() if (method == \"mode\") and (val","h, [int, float]), (\"cat_priority\", cat_priority, [list]), ] ) if by:","in zscore|minmax\" warnings.warn(warning_message, Warning) return self mad, med = self.aggregate([\"mad\",","\"float\", \"float\", ) ] elif method == \"robust_zscore\": if n","unit: str, optional Slice size unit. For example, it can","If the function has two arguments (example, power or mod),","+ total) / self.parent.shape()[0] ) except: pass total = int(total)","the input vColumns using the input method. Parameters ---------- method:","matches in each of the vColumn records by an input","== \"same_freq\") or ( self.isnum() and method == \"smart\" ):","isinstance(by, str): by = [by] check_types( [ (\"method\", method, [\"zscore\",","if self.category() in [\"date\", \"float\"]: warning_message = ( \"label_encode is","percentile = 0.9) AS 'approx_90%', MAX({3}{4}) AS max FROM vdf_table\"\"\".format(","= self.count() if (method == \"mode\") and (val == None):","else: if verticapy.options[\"print_info\"]: print(\"Nothing was filled.\") self.transformations = [elem for","_ _| _ /~\\ _ |. # |_)\\/ |_)(_|(_|| \\_/|_|(_|||","will filter the data when 'ts' is lesser than November","Bar Chart of vColumn based on an aggregation. \"\"\" check_types(","/ / /\\ ___\\ /\\ __ \\ /\\ \\ /\\","in kwargs): from verticapy.plot import gen_colors kwargs[\"color\"] = gen_colors()[0] if","NULLIFZERO(SUM(events) OVER ()) AS pt_events FROM ({}) x\".format( self.alias, query,","\"fd\", \"auto\"])] ) method = method.lower() if method == \"auto\":","= \"(SELECT {} FROM {}{} OFFSET {}{}) VERTICAPY_SUBTABLE\".format( self.alias, self.parent.__genSQL__(),","of elements. density : Percentage of the distribution. mean :","data. Parameters ---------- new_name: str The new vColumn alias. Returns","as e: raise QueryError( \"{}\\nError when applying the func 'x","NULLIFZERO(SUM(non_events) OVER ()) AS pt_non_events, events / NULLIFZERO(SUM(events) OVER ())","of the above. The idea is simple: instead of moving","the vDataFrame expected store usage. \"\"\" pre_comp = self.parent.__get_catalog_value__(self.alias, \"store_usage\")",": Draws the Bar Chart of vColumn based on an","numcol, self.alias ) values = to_tablesample(query, title=title).values elif ( ((distinct_count","text_info ) ) return self.parent # ---# def mad(self): \"\"\"","IS NOT NULL GROUP BY 1 ORDER BY 2 DESC","defined. numerical : Uses popular numerical aggregations during the computation.","nth_elems = nb, [], [] while total < int(float(count /","element.\", method=\"fetchfirstelem\", ) else: return getattr(self, index) # ---# def","must be one of the following: CENTURY / DAY /","self.ctype(), self.category())] self.transformations += final_transformation sauv = {} for elem","int(math.floor(math.log(count, 2) + 2)), 1e-99, ) fd = max(2.0 *","alpha], [self.alias]) .transpose() .values[self.alias] ) self.parent.filter( \"({} BETWEEN {} AND","IS NOT NULL\".format(self.alias)) return self.parent # ---# def fill_outliers( self,","NULLIFZERO(pt_events))) END AS woe, CASE WHEN non_events = 0 OR","--------------------------------------------------------------------------- Encodes the vColumn using a user-defined encoding. Parameters ----------","= \"SELECT {}{} FROM {}{} OFFSET {} LIMIT 1\".format( self.alias,","\"rose\"]), ] ) donut = True if pie_type == \"donut\"","each record of the vColumn. The vColumn will be transformed.","str, optional Prefix of the dummies. prefix_sep: str, optional Prefix","and offers beautiful graphical options. # # VerticaPy aims to","using. Returns ------- tablesample An object containing the result. For","Converts the vColumn to the input type. Parameters ---------- dtype:","numeric|date\" ) if self.isnum(): result = ( self.parent.describe( method=\"numerical\", columns=[self.alias],","self.apply( func=\"TIME_SLICE({}, {}, '{}', '{}')\".format( \"{}\", length, unit.upper(), start_or_end )","otherwise. Returns ------- bool True if the vColumn category is","int(float(count / int(nbins))) * int(nbins): nth_elems += [str(total)] total +=","( \"({} - {}) / {}({})\".format( \"{}\", avg, \"NULLIFZERO\" if","\"\"\" --------------------------------------------------------------------------- Drops the vColumn from the vDataFrame. Dropping a","AS {}, {} AS ord, {}::int AS {} FROM {}\".format(","lesser than the lower bound to the lower bound itself","vDataFrame.aggregate : Computes the vDataFrame input aggregations. \"\"\" return self.aggregate([\"variance\"]).values[self.alias][0]","Also -------- vDataFrame[].fill_outliers : Fills the vColumn outliers using the","[], self.distinct() if len(cat) == 1: lp, rp = \"(\",","the parameter is empty or invalid. max_cardinality: int, optional Maximum","self.isbool(): warning_message = \"Normalize doesn't work on booleans\".format(self.alias) warnings.warn(warning_message, Warning)",": Extracts the regular expression in each record of the","--------------------------------------------------------------------------- Returns the category of the vColumn. The category will","the optimal h.\", method=\"fetchrow\", ) count, vColumn_min, vColumn_025, vColumn_075, vColumn_max","partition the TS. start_date: str / date, optional Input Start","for elem in copy_trans] raise QueryError(\"{}\\nAn Error happened during the","the statics of {} partitioned by {}.\".format( numcol, self.alias )","max_cardinality, [int, float]), (\"h\", h, [int, float]), (\"cat_priority\", cat_priority, [list]),","and max). (x - min) / (max - min) by:","self.parent.shape()[0] self.catalog[\"percent\"] = 100 self.parent.__add_to_history__( \"[Label Encoding]: Label Encoding was","str = \"density\", of: str = \"\", max_cardinality: int =","else: final_transformation = [ ( \"({} - {}) / ({})\".format(\"{}\",","(\"of\", of, [str]), (\"max_cardinality\", max_cardinality, [int, float]), (\"h\", h, [int,","self.transformations = [elem for elem in copy_trans] raise QueryError(\"{}\\nAn Error","already computed aggregations to gain in performance. The catalog will","result[i][2] = None avg = \"DECODE({}, {}, NULL)\".format( by[0], \",","WHERE {} > {})\".format( self.parent.__genSQL__(), self.alias, self.alias, p_alpha, self.alias, self.alias,","Creates a copy of the vColumn. \"\"\" check_types([(\"new_name\", new_name, [str])])","apply_fun(self, func: str, x: float = 2): \"\"\" --------------------------------------------------------------------------- Applies","= \"WITH vdf_table AS (SELECT * FROM {}) {}\".format( self.parent.__genSQL__(),","(or approximate quantile). See Also -------- vDataFrame.aggregate : Computes the","LIMIT {} OFFSET {}\".format( bin_spatial_to_str(self.category(), self.alias), self.alias, self.parent.__genSQL__(), self.parent.__get_last_order_by__(), limit,","of type date like. Optimized h will be computed if","FROM {}{} OFFSET {}{}) VERTICAPY_SUBTABLE\".format( self.alias, self.parent.__genSQL__(), self.parent.__get_last_order_by__(), index_start, limit,","{} THEN {} \".format(\"{}\", lower, lower) if (isinstance(lower, (float, int)))","aggregation. Parameters ---------- by: str, optional vColumn to use to","method to use to discretize the vColumn. auto : Uses","to the vColumn. \"\"\" check_types( [ ( \"func\", func, [","Looks if some specific records are in the vColumn and","or of type date like. Optimized h will be computed","FROM (SELECT {}, COUNT(*) AS _verticapy_cnt_ FROM {}{}GROUP BY {}","# # VerticaPy aims to do all of the above.","on an aggregation. Parameters ---------- method: str, optional The method","Returns the transformation instead of the vDataFrame parent and do","mean encoding of a response. \"\"\" if self.category() in [\"date\",","name = quote_ident(name.replace('\"', \"_\")) assert name.replace('\"', \"\"), EmptyParameter( \"The parameter","isinstance(index, int): cast = \"::float\" if self.category() == \"float\" else","bool, optimal If set to True, the method will return","computed) ax: Matplotlib axes object, optional The axes to plot","# _____________ / / # \\ / / / #",".transpose() .values[self.alias] ) self.parent.filter( \"({} BETWEEN {} AND {})\".format(self.alias, p_alpha,","elif method == \"minmax\": self.catalog[elem] = (sauv[elem] - sauv[\"min\"]) /","= 6, h: float = 0, pie_type: str = \"auto\",","False, ax=None, **style_kwds, ): \"\"\" --------------------------------------------------------------------------- Draws the Time Series","[str, datetime.datetime, datetime.date, int, float], ), ( \"end_date\", end_date, [str,","'same_width' for numerical vColumns, cast the other types to varchar.","optional Value to use to impute the vColumn. method: dict,","self.catalog[elem] = sauv[elem] return self.parent # ---# def geo_plot(self, *args,","the Robust Z-Score (median and mad). (x - median) /","in (\"None\", None)) else \" WHERE {} = '{}'\".format( bin_spatial_to_str(self.category(),","# ---# def mad(self): \"\"\" --------------------------------------------------------------------------- Aggregates the vColumn using","utilities.tablesample. See Also -------- vDataFrame[].nlargest : Returns the n largest","\"{}({})\".format(func.upper(), \"{}\") else: expr = \"{}({}, {})\".format(func.upper(), \"{}\", x) return",".replace(\"'\", \"_\") ) expr = \"DECODE({}, '{}', 1, 0)\".format( \"{}\",","returns the new vDataFrame of the search. Parameters ---------- val:",": Average. median : median. mode : mode (most occurent","model.fit(tmp_view_name, [self.alias], response) query = [ \"(SELECT READ_TREE(USING PARAMETERS model_name","Aggregates the vColumn using 'kurtosis'. Returns ------- float kurtosis See","at risk dtype : vColumn type iqr : interquartile range","AND {} THEN '[{};{}]' \".format( \"{}\", result[i - 1], result[i],","\"top\") if pre_comp != \"VERTICAPY_NOT_PRECOMPUTED\": if not (dropna) and (pre_comp","executeSQL( \"SELECT {}, {} FROM {} LIMIT 1\".format( cmax, cmin,","self.min() table = \"(SELECT DATEDIFF('second', '{}'::timestamp, {}) AS {} FROM","+= [sum(result[\"non_events\"])] result.values[\"events\"] += [sum(result[\"events\"])] result.values[\"pt_non_events\"] += [\"\"] result.values[\"pt_events\"] +=",": product range : difference between the max and the","result[0][0] if not (dropna): n = \"\" if (n ==","to order the data. The vColumn type must be date","apply the function: x -> x^2 + 2 use \"POWER({},","using 'sum'. Returns ------- float sum See Also -------- vDataFrame.aggregate","null !\".format( self.alias ) warnings.warn(warning_message, Warning) return self elif method","---# def abs(self): \"\"\" --------------------------------------------------------------------------- Applies the absolute value function","of the first element (Constant Interpolation). mean : Average. median","of: self.parent.are_namecols_in(of) of = self.parent.format_colnames(of) from verticapy.plot import bar return","express or implied. # See the License for the specific","vColumn_075, vColumn_max = ( result[0], result[3], result[4], result[6], result[7], )","FROM {}) {}\".format( self.parent.__genSQL__(), query ) query_result = executeSQL( query=query,","---# def sem(self): \"\"\" --------------------------------------------------------------------------- Aggregates the vColumn using 'sem'","{}, \"regr_avgy\": {}, \"regr_count\": {}, \"regr_intercept\": {}, \"regr_r2\": {}, \"regr_slope\":","the numerical and Mode for the categorical vColumns. bfill :","forbidden !\") return self.apply(func=\"{} / ({})\".format(\"{}\", x)) # ---# def","series rule. \"\"\" return self.apply(func=\"DATE_PART('{}', {})\".format(field, \"{}\")) # ---# def","if h > 0.01: h = round(h, 2) elif h","self.alias) query = \"SELECT {} AS {}, {} AS ord,","--------------------------------------------------------------------------- Draws the range plot of the vColumn. The aggregations",": Computes the vDataFrame input aggregations. \"\"\" return self.aggregate([\"sem\"]).values[self.alias][0] #","transformations: list = [], parent=None, catalog: dict = {} ):","filled.\".format( total, self.alias, conj, ) ) else: if verticapy.options[\"print_info\"]: print(\"Nothing","PARAMETERS percentile = 0.75) AS 'approx_75%', APPROXIMATE_PERCENTILE ({3}{4} USING PARAMETERS","------- float/str median See Also -------- vDataFrame.aggregate : Computes the",": Normalization using the Z-Score (avg and std). (x -","the vColumn records. The vColumn will be transformed. Parameters ----------",") ) else: for k in range(max_floor): self.transformations += [(\"{}\",","= (\"{} || ''\", \"varchar\", \"text\") if (self.isnum() and method",") warnings.warn(warning_message, Warning) return self.parent if isinstance(val, str): val =","{} IS NOT NULL ORDER BY {} ASC LIMIT {}\".format(","\"\"\" check_types( [ (\"breaks\", breaks, [list]), (\"labels\", labels, [list]), (\"include_lowest\",","\"auto\", max_cardinality: int = 6, numcol: str = \"\" ):","the vDataFrame input aggregations. \"\"\" return self.aggregate([\"aad\"]).values[self.alias][0] # ---# def","sine sinh : hyperbolic sine sqrt : arithmetic square root","breaks: list, labels: list = [], include_lowest: bool = True,","gen_colors from matplotlib.lines import Line2D colors = gen_colors() if not","ax=None, **style_kwds, ): \"\"\" --------------------------------------------------------------------------- Draws the Time Series of","__ ______ ______ __ __ __ __ __ __ __","idx == 0: op1, close_l = \"<\", \"]\" if labels:","the parameter 'x' will represent the number of seconds, otherwise","str): pie_type = pie_type.lower() check_types( [ (\"method\", method, [str]), (\"of\",","# ---# def add_copy(self, name: str): \"\"\" --------------------------------------------------------------------------- Adds a","\"\"\" --------------------------------------------------------------------------- Aggregates the vColumn using 'kurtosis'. Returns ------- float","# ---# def mean_encode(self, response: str): \"\"\" --------------------------------------------------------------------------- Encodes the","applying the func 'x -> {}' to '{}'\".format( e, func.replace(\"{}\",","OR events = 0 THEN 0 ELSE (pt_non_events - pt_events)","title=\"Computing the different aggregations.\", method=\"fetchall\", ) for idx, elem in","Normalizes the input vColumns using the input method. Parameters ----------","USING PARAMETERS percentile = 0.25) AS Q1, APPROXIMATE_PERCENTILE({} USING PARAMETERS","({})\".format(\"{}\", x)) # ---# def drop(self, add_history: bool = True):","**kwargs Any optional parameter to pass to the geopandas plot","MONTH / QUARTER / SECOND / TIME ZONE / TIMEZONE_HOUR","self.nunique(True) > 6) else \"mode\" total = self.count() if (method","and 1 (1 meaning global outlier). \"\"\" if isinstance(method, str):","higher than the upper bound to the upper bound itself.","float skewness See Also -------- vDataFrame.aggregate : Computes the vDataFrame","- 1] (n being the vColumn cardinality). Returns ------- vDataFrame","SQL code generation will be slower if the vDataFrame has","ParameterError( \"The parameter 'numcol' must be a vDataFrame column if","to_replace: str, value: str = \"\"): \"\"\" --------------------------------------------------------------------------- Replaces the","str vColumn category. See Also -------- vDataFrame[].ctype : Returns the","NULL\".format(self.alias)) return self.parent # ---# def fill_outliers( self, method: str","{} AS {}, {} AS verticapy_agg FROM {} WHERE {}","float]), (\"nbins\", nbins, [int, float]), ] ) if of: self.parent.are_namecols_in(of)","(sauv[elem] - sauv[\"mean\"]) / sauv[ \"std\" ] elif method ==","vDataFrame. \"\"\" check_types([(\"add_history\", add_history, [bool])]) try: parent = self.parent force_columns","self.catalog[\"percent\"] = 100 self.parent.__add_to_history__( \"[Label Encoding]: Label Encoding was applied","of the vColumn {} named {} was added to the","== len(labels) + 1 or not (labels), ParameterError( \"Length of","parent=self.parent, transformations=transformations, catalog={ \"min\": 0, \"max\": 1, \"count\": self.parent.shape()[0], \"percent\":","def mad(self): \"\"\" --------------------------------------------------------------------------- Aggregates the vColumn using 'mad' (median","(float, int))) else \"\" ) func = \"(CASE {}{}ELSE {}","= {self.alias: val} return self.parent.isin(val) # ---# def isnum(self): \"\"\"",") ] elif method == \"robust_zscore\": if n > 0:","column if the method is 'cat_stats'\" ) distinct_count, is_numeric, is_date","\".join(by) ), ) else: avg, stddev = ( \"AVG({}) OVER",") custom_lines += [ Line2D( [0], [0], color=updated_dict(param, style_kwds, idx)[\"color\"],","self.parent.are_namecols_in([elem for elem in order_by] + by) by = self.parent.format_colnames(by)","response column must be numerical to use a mean encoding\"","{column} AND {column} {op2} '{second_elem}' THEN '{label}'\" ] expr =","str_contains(self, pat: str): \"\"\" --------------------------------------------------------------------------- Verifies if the regular expression","(), PERCENTILE_CONT(1 - {}) WITHIN GROUP (ORDER BY {}) OVER","/ # ______ / / # \\ / / /","1.0, kernel: str = \"gaussian\", nbins: int = 200, xlim:","if \"agg\" not in kwargs: query = \"SELECT {} AS","transforms the vColumn using a time series rule. Parameters ----------","def add_copy(self, name: str): \"\"\" --------------------------------------------------------------------------- Adds a copy vColumn","bound to the upper bound itself. Parameters ---------- lower: float,","method = method.lower() if self.isnum() and method == \"smart\": schema","not (result) else result[0][0] if not (dropna): n = \"\"","variance Other aggregations could work if it is part of","vDataFrame. \"\"\" if isinstance(val, str) or not (isinstance(val, Iterable)): val","bijection from the different categories to [0, n - 1]","(No h will be picked or computed) h: float, optional","by if method in [\"ffill\", \"pad\", \"bfill\", \"backfill\"]: all_partition +=","0.05, ): \"\"\" --------------------------------------------------------------------------- Fills the vColumns outliers using the","{}) / {}({})\".format( self.alias, avg, \"NULLIFZERO\" if (nullifzero) else \"\",","val: list List of the different records. For example, to","FROM (SELECT {} AS {}, {} AS verticapy_agg FROM {}","+ 1) query = \"WITH vdf_table AS (SELECT * FROM","\"end_date\", end_date, [str, datetime.datetime, datetime.date, int, float], ), (\"plot_median\", plot_median,","Warning) return self elif method == \"minmax\": if n ==","STDDEV({}) FROM {} GROUP BY {}\".format( by[0], self.alias, self.alias, self.parent.__genSQL__(),","represents Q1. approx: bool, optional If set to True, the","if method.lower() == \"sturges\": best_h = sturges elif method.lower() in","self.transformations += [(expr, \"int\", \"int\")] self.parent.__update_catalog__(erase=True, columns=[self.alias]) self.catalog[\"count\"] = self.parent.shape()[0]","(self.isnum() and self.nunique(True) > 6) else \"mode\" total = self.count()","IS NULL\".format(self.alias) if (category in (\"None\", None)) else \" WHERE",": Returns the head of the vColumn. \"\"\" return self.iloc(limit=limit,","xmin, xmax = xlim custom_lines = [] columns = self.parent[by].distinct()","!= \"numerical\")) or not (is_numeric) or (method == \"categorical\") ):","2 in case of discretization using the method 'topk'\" )","the same number of elements. same_width : Computes regular width","i in range(1, n): trans += \"WHEN {} BETWEEN {}","index, self.alias: result}) for elem in values: for i in","): \"\"\" --------------------------------------------------------------------------- Fills the vColumns outliers using the input",") method = method.lower() self.parent.are_namecols_in(by) by = self.parent.format_colnames(by) nullifzero, n","getattr(self, index) # ---# def __len__(self): return int(self.count()) # ---#","their distributions as percents. Parameters ---------- k: int, optional Number","1] ... ELSE argv[n] END Returns ------- vDataFrame self.parent See","AS {}, COUNT(*) AS _verticapy_cnt_, 100 * COUNT(*) / {}","consider when drawing the box plot. The other categories will","\\____ \\ \\ \\_\\ \\ \\ \\ \\-./\\ \\ \\","bool, optional Returns the transformation instead of the vDataFrame parent","y, y, self.parent.__genSQL__(), ) query = \"SELECT {}, MIN(ord) AS","the 'alpha' parameter. alpha: float, optional Number representing the outliers","# ---# def head(self, limit: int = 5): \"\"\" ---------------------------------------------------------------------------","FROM {} WHERE {} IS NOT NULL GROUP BY 1)","# \\ / # \\ / # \\/ # _","AS (SELECT * FROM {}) {}\".format( self.parent.__genSQL__(), \" UNION ALL","be dropped. Returns ------- vDataFrame self.parent See Also -------- vDataFrame.fill_outliers","self.parent See Also -------- vDataFrame[].decode : Encodes the vColumn using","utilities.tablesample. See Also -------- vDataFrame[].head : Returns the head of","'breaks' must be greater or equal to 2.\" ) assert","if of: self.parent.are_namecols_in(of) of = self.parent.format_colnames(of) from verticapy.plot import bar","-------- vDataFrame.isin : Looks if some specific records are in","200, xlim: tuple = None, ax=None, **style_kwds, ): \"\"\" ---------------------------------------------------------------------------","a list of at least one element to use to","ctype # ---# def date_part(self, field: str): \"\"\" --------------------------------------------------------------------------- Extracts","elem in self.transformations] total = self.count() if method not in","def iv_woe(self, y: str, nbins: int = 10): \"\"\" ---------------------------------------------------------------------------","(date, datetime, timestamp...) or numerical. q: tuple, optional Tuple including","\"mod\", \"pow\", \"round\"): expr = \"{}({})\".format(func.upper(), \"{}\") else: expr =","# ---# def __len__(self): return int(self.count()) # ---# def __nonzero__(self):","import gen_cmap kwargs[\"cmap\"] = gen_cmap()[0] else: if not (\"color\" in","\"\"\" check_types( [ (\"prefix\", prefix, [str]), (\"prefix_sep\", prefix_sep, [str]), (\"drop_first\",","matches in each of the vColumn record by an input","[ \"'{}'\".format(str(elem).replace(\"'\", \"''\")) for elem in distinct ] ), bin_spatial_to_str(self.category()),","\\ \\_\\ \\ \\ \\ \\-./\\ \\ \\ \\ \\-.","whole number ln : natural logarithm log : logarithm log10","(\"method\", method, [\"auto\", \"numerical\", \"categorical\", \"cat_stats\"]), (\"max_cardinality\", max_cardinality, [int, float]),","of values used to cut the vColumn. labels: list, optional","method=\"fetchall\", ) result = [elem[0] for elem in result] except:","# ---# def isdate(self): \"\"\" --------------------------------------------------------------------------- Returns True if the","elif method in (\"mean\", \"avg\", \"median\"): fun = \"MEDIAN\" if","var See Also -------- vDataFrame.aggregate : Computes the vDataFrame input","Slice size. unit: str, optional Slice size unit. For example,","how often they occur, and other statistical information. Parameters ----------","copy_name: str = \"\"): \"\"\" --------------------------------------------------------------------------- Applies a function to","max_floor ) except: pass max_floor -= len(self.transformations) if copy_name: self.add_copy(name=copy_name)","\"null\", \"mean\"]), (\"alpha\", alpha, [int, float]), (\"use_threshold\", use_threshold, [bool]), (\"threshold\",","--------------------------------------------------------------------------- Draws the bar chart of the vColumn based on","[list]), ] ) if by: self.parent.are_namecols_in(by) by = self.parent.format_colnames(by) from","dummy to avoid the creation of correlated features. use_numbers_as_suffix: bool,","result[\"std\"][0] + result[\"avg\"][0], ) else: query = \"SELECT PERCENTILE_CONT({}) WITHIN","= self.parent.format_colnames(by) columns = [self.alias, by] else: columns = [self.alias]","func=\"REGEXP_REPLACE({}, '{}', '{}')\".format( \"{}\", to_replace.replace(\"'\", \"''\"), value.replace(\"'\", \"''\") ) )","+= [(\"{}\", self.ctype(), self.category())] self.transformations += [(new_column, ctype, category)] try:","SQL used to transform the vColumn. The function variable must","if the response is numerical (except ints and bools), a","vColumns to use to sort the data when using TS","# ---# def str_count(self, pat: str): \"\"\" --------------------------------------------------------------------------- Computes the","label = labels[idx] else: label = f\"{close_l}{first_elem};{second_elem}{close_r}\" conditions += [","--------------------------------------------------------------------------- Fills the vColumns outliers using the input method. Parameters","Also -------- vDataFrame.donut : Draws the donut chart of the","pat: str): \"\"\" --------------------------------------------------------------------------- Computes the number of matches for","axes to plot on. **style_kwds Any optional parameter to pass","expected store usage. \"\"\" pre_comp = self.parent.__get_catalog_value__(self.alias, \"store_usage\") if pre_comp","response, [str])]) self.parent.are_namecols_in(response) response = self.parent.format_colnames(response) assert self.parent[response].isnum(), TypeError( \"The","100 * COUNT(*) / {} AS percent FROM {}{} GROUP","\"mode\", \"0ifnull\", \"mean\", \"avg\", \"median\", \"ffill\", \"pad\", \"bfill\", \"backfill\", ],","see utilities.tablesample. See Also -------- vDataFrame.aggregate : Computes the vDataFrame","sum See Also -------- vDataFrame.aggregate : Computes the vDataFrame input",": Percentage of the distribution. mean : Average of the","**kwargs) # ---# def get_dummies( self, prefix: str = \"\",","self.parent.are_namecols_in(of) of = self.parent.format_colnames(of) from verticapy.plot import pie return pie(","iv_woe.\".format(y) ) response_cat = self.parent[y].distinct() response_cat.sort() assert response_cat == [0,","The idea is simple: instead of moving # data around","elements. density : Percentage of the distribution. mean : Average","keep after the comma. Returns ------- vDataFrame self.parent See Also","import range_curve_vdf return range_curve_vdf( self, ts, q, start_date, end_date, plot_median,","+ result, } if ((is_date) and not (method == \"categorical\"))","on an aggregation. Parameters ---------- by: str, optional vColumn to","= (sauv[elem] - sauv[\"mean\"]) / sauv[ \"std\" ] elif method","str_replace(self, to_replace: str, value: str = \"\"): \"\"\" --------------------------------------------------------------------------- Replaces","elem[1] != None ] ), ) stddev = \"DECODE({}, {},","FROM vdf_table\"\"\".format( category, self.alias, self.parent.shape()[0], numcol, cast, ) tmp_query +=","new vColumn labeled with 0 and 1 (1 meaning global","drawn. ax: Matplotlib axes object, optional The axes to plot","will look like: even: CASE ... WHEN vColumn = argv[2","(ex: 50% to get the median). It can also be","(SELECT * FROM {}) {}\".format( self.parent.__genSQL__(), query ) query_result =","{}, {} AS verticapy_agg FROM {} WHERE {} IS NOT","query=query, title=\"Computing the optimized histogram nbins using Random Forest.\", method=\"fetchall\",","str_sql): func = str(func) check_types([(\"func\", func, [str]), (\"copy_name\", copy_name, [str])])","(\"max_cardinality\", max_cardinality, [int, float]), (\"h\", h, [int, float]), (\"cat_priority\", cat_priority,","top1 for the mode) topk_percent : kth most occurent element","[str]), (\"by\", by, [str]), (\"start_date\", start_date, [str, datetime.datetime, datetime.date]), (\"end_date\",","to be used as categorical (No h will be picked",": Computes the vColumn descriptive statistics. \"\"\" return self.describe(method=\"categorical\", max_cardinality=k)","brackets {}. For example to apply the function: x ->","specified name. \\u26A0 Warning : SQL code generation will be","BY {}))\".format( \"{}\", \"{}\", partition_by, order_by_ts ) if method in","stddev ) else: final_transformation = [ ( \"({} - {})","Deviation). Returns ------- float aad See Also -------- vDataFrame.aggregate :",") assert self.isnum() or self.isdate(), TypeError( \"cut only works on","usage. See Also -------- vDataFrame.expected_store_usage : Returns the vDataFrame expected",": Computes the vDataFrame input aggregations. \"\"\" check_types( [ (\"method\",","chart. auto : Regular pie chart. donut : Donut chart.","\"\"\" --------------------------------------------------------------------------- Aggregates the vColumn using 'min' (Minimum). Returns -------","PERCENTILE_CONT(1 - {}) WITHIN GROUP (ORDER BY {}) OVER ()","Aggregates the vColumn using 'aad' (Average Absolute Deviation). Returns -------","the function has two arguments (example, power or mod), 'x'","2 to be used as categorical (No h will be","vColumn is boolean. See Also -------- vDataFrame[].isdate : Returns True","max_cardinality, [int, float]), (\"numcol\", numcol, [str]), ] ) method =","of the vColumn. \"\"\" check_types([(\"new_name\", new_name, [str])]) old_name = quote_ident(self.alias)","{})\".format(len(distinct_elements)) self.transformations += [(expr, \"int\", \"int\")] self.parent.__update_catalog__(erase=True, columns=[self.alias]) self.catalog[\"count\"] =","auto : Regular pie chart. donut : Donut chart. rose","if the vColumn category is date. \"\"\" return self.category() in","verticapy.stats as st return self.apply(func=st.decode(str_sql(\"{}\"), *argv)) # ---# def density(",": arithmetic sign sin : trigonometric sine sinh : hyperbolic","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","max_floor: max_floor = len(self.parent[elem].transformations) max_floor -= len(self.transformations) for k in","'{}') > 0\".format(\"{}\", pat.replace(\"'\", \"''\")) ) # ---# def str_count(self,","sauv: self.catalog[\"count\"] = sauv[\"count\"] self.catalog[\"percent\"] = ( 100 * sauv[\"count\"]","n, [int, float])]) return self.apply(func=\"ROUND({}, {})\".format(\"{}\", n)) # ---# def","License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by","Number of elements to display. offset: int, optional Number of","to 2 in case of discretization using the method 'topk'\"","min : minimum mode : most occurent element percent :","\\ / _ __|_. _ _ |_) # \\/ (/_|","mode) topk_percent : kth most occurent element density unique :","= self.count() nb = int(float(count / int(nbins))) assert nb !=","\\u26A0 Warning : SQL code generation will be slower if","[list]), (\"h\", h, [list, float, int]), ] ) if by:","computed if the parameter is empty or invalid. max_cardinality: int,",") cast = \"::int\" if (self.parent[numcol].isbool()) else \"\" query, cat","vDataFrame[].slice : Slices the vColumn using a time series rule.","the input number of digits after the comma. Parameters ----------","), \"float\", \"float\", ) ] elif method == \"robust_zscore\": if","applied to the vColumn {}\\n{} feature{}created: {}\".format( self.alias, len(all_new_features), conj,","by: str = \"\", h: float = 0, max_cardinality: int","result[\"std\"][0] + result[\"avg\"][0], threshold * result[\"std\"][0] + result[\"avg\"][0], ) else:","END odd : CASE ... WHEN vColumn = argv[2 *","\"winsorize\": self.clip(lower=p_alpha, upper=p_1_alpha) elif method == \"null\": self.apply( func=\"(CASE WHEN","Also -------- vDataFrame.bar : Draws the Bar Chart of the","to draw the Plot. start_date: str / date, optional Input","must be binary to use iv_woe.\".format(y) ) response_cat = self.parent[y].distinct()","-------- vDataFrame.plot : Draws the time series. \"\"\" check_types( [","def tail(self, limit: int = 5): \"\"\" --------------------------------------------------------------------------- Returns the","input quantiles. Parameters ---------- ts: str TS (Time Series) vColumn","avg, stddev, self.parent.__genSQL__() ), print_time_sql=False, ) except: avg, stddev =","list = [], order_by: list = [], ): \"\"\" ---------------------------------------------------------------------------","vColumn cardinality). Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].decode","/ float / text / binary / spatial / uuid","smallest elements.\".format(n, self.alias) return to_tablesample(query, title=title) # ---# def numh(self,","True, the Median will be drawn. ax: Matplotlib axes object,","{}, {} FROM {} LIMIT 1\".format( cmax, cmin, self.parent.__genSQL__() ),","x: float Input number. Returns ------- vDataFrame self.parent See Also","(ORDER BY {}) OVER () FROM {} LIMIT 1\".format( alpha,","if return_trans: return \"({} - {}) / ({})\".format(self.alias, med, mad)","use to aggregate the data. count : Number of elements.","== 1) and (self.parent[by[0]].nunique() < 50): try: result = executeSQL(","\\/ (/_| | |(_(_|| \\/ # / # VerticaPy is","new_column = \"COALESCE({}, DECODE({}, {}, NULL))\".format( \"{}\", by[0], \", \".join(","nbins, [int])]) self.parent.are_namecols_in(y) y = self.parent.format_colnames(y) assert self.parent[y].nunique() == 2,",") start_or_end = \"START\" if (start) else \"END\" return self.apply(","), ] ax.set_title(\"KernelDensity\") ax.legend( custom_lines, columns, title=by, loc=\"center left\", bbox_to_anchor=[1,","mode (only missing values).\\nNothing was filled.\".format( self.alias ) warnings.warn(warning_message, Warning)","from the vColumn. \"\"\" check_types( [ (\"length\", length, [int, float]),","offset: int, optional Number of elements to skip. Returns -------","or invalid. max_cardinality: int/tuple, optional Maximum number of distinct elements","Divides the vColumn by the input element. Parameters ---------- x:","the following list: [\"Fouad\", \"Badr\"] Returns ------- vDataFrame The vDataFrame","= \"::int\" if (self.parent[numcol].isbool()) else \"\" query, cat = [],","[ (\"length\", length, [int, float]), (\"unit\", unit, [str]), (\"start\", start,","min sem : standard error of the mean skewness :",": Computes the vDataFrame input aggregations. \"\"\" return self.aggregate([\"avg\"]).values[self.alias][0] mean","str) or not (isinstance(cat_priority, Iterable)): cat_priority = [cat_priority] check_types( [","\"NULL\", elem[1] if elem[1] != None else \"NULL\", ) for","the vColumn. vDataFrame.outliers : Adds a new vColumn labeled with","= vColumn( name, parent=self.parent, transformations=transformations, catalog={ \"min\": 0, \"max\": 1,","------- ax Matplotlib axes object See Also -------- vDataFrame.donut :","'approx_50%', APPROXIMATE_PERCENTILE ({3}{4} USING PARAMETERS percentile = 0.75) AS 'approx_75%',","--------------------------------------------------------------------------- Adds the input element to the vColumn. Parameters ----------","Note: Dropping a vColumn can make the vDataFrame \"heavier\" if","return self.apply(func=\"TIMESTAMPADD(SECOND, {}, {})\".format(x, \"{}\")) else: return self.apply(func=\"{} + ({})\".format(\"{}\",","+ result[\"avg\"][0], ) else: query = \"SELECT PERCENTILE_CONT({}) WITHIN GROUP","== \"0ifnull\": category, ctype = \"int\", \"bool\" else: category, ctype","self.alias, query, ) title = \"Computing WOE & IV of","column in enumerate(columns): param = {\"color\": colors[idx % len(colors)]} ax","\"({} - {}) / {}({} - {})\".format( \"{}\", cmin, \"NULLIFZERO\"","str Regular expression to replace. value: str, optional New value.","Parameters ---------- prefix: str, optional Prefix of the dummies. prefix_sep:","sturges elif method.lower() in (\"freedman_diaconis\", \"fd\"): best_h = fd else:","(len(by) == 1) and (self.parent[by[0]].nunique() < 50): try: if fun","{}{} GROUP BY {} ORDER BY _verticapy_cnt_ DESC {}\".format( bin_spatial_to_str(self.category(),","kernel = kernel.lower() from verticapy.learn.neighbors import KernelDensity schema = verticapy.options[\"temp_schema\"]","def apply(self, func: str, copy_name: str = \"\"): \"\"\" ---------------------------------------------------------------------------","new categories. If empty, names will be generated. include_lowest: bool,","THEN '[{};{}]' \".format( \"{}\", result[i - 1], result[i], result[i -","------- bool True if the vColumn category is date. See","''\", \"varchar\", \"text\") if (self.isnum() and method == \"same_freq\") or","if func not in (\"log\", \"mod\", \"pow\", \"round\"): expr =","{} \".format(\"{}\", upper, upper) if (isinstance(upper, (float, int))) else \"\"","Prefix delimitor of the dummies. drop_first: bool, optional Drops the","== \"is_numeric\" ): self.parent.__update_catalog__({\"index\": index, self.alias: result}) for elem in","verticapy.plot import gen_colors kwargs[\"color\"] = gen_colors()[0] if not (\"legend\" in","{} LIMIT 1\".format( new_column.format(self.alias), self.parent.__genSQL__() ), print_time_sql=False, ) except: new_column","[\"sturges\", \"freedman_diaconis\", \"fd\", \"auto\"])] ) method = method.lower() if method","20, \"max_depth\": 10} to train a Random Forest with 20","parent = self.drop(add_history=False) parent.__add_to_history__( \"[Rename]: The vColumn {} was renamed","_verticapy_cnt_ DESC {}\".format( bin_spatial_to_str(self.category(), self.alias), self.alias, self.parent.shape()[0], self.parent.__genSQL__(), dropna, self.alias,","({})\".format(self.alias, med, mad) else: final_transformation = [ ( \"({} -","* result[\"std\"][0] + result[\"avg\"][0], threshold * result[\"std\"][0] + result[\"avg\"][0], )","**style_kwds) # ---# def iloc(self, limit: int = 5, offset:","be used as categorical. The less frequent elements will be","See Also -------- vDataFrame[].head : Returns the head of the","[bool]), (\"threshold\", threshold, [int, float]), ] ) if use_threshold: result","for the median) prod : product range : difference between","(\"return_enum_trans\", return_enum_trans, [bool]), (\"h\", h, [int, float]), (\"response\", response, [str]),","] ) if use_threshold: result = self.aggregate(func=[\"std\", \"avg\"]).transpose().values self.parent.filter( \"ABS({}","result = self.aggregate(func=[\"std\", \"avg\"]).transpose().values self.parent.filter( \"ABS({} - {}) / {}","if not (\"figsize\" in kwargs): kwargs[\"figsize\"] = (14, 10) return","method. Parameters ---------- method: str, optional Method to use to","= \"SELECT {} AS index, non_events, events, pt_non_events, pt_events, CASE","the alias of one of the dummies ({name}).\\n\" \"It can","{}\".format( self.parent.__genSQL__(), query ) query_result = executeSQL( query=query, title=\"Computing the","\" if verticapy.options[\"print_info\"]: print(\"{} element{}filled.\".format(total, conj)) self.parent.__add_to_history__( \"[Fillna]: {} {}","to the input vColumns. vDataFrame.applymap : Applies a function to","/ DAY / DECADE / DOQ / DOW / DOY","\"\"\" check_types([(\"dropna\", dropna, [bool]), (\"n\", n, [int, float])]) if n","\"\"\" check_types([(\"x\", x, [int, float])]) return self.apply(func=\"{} * ({})\".format(\"{}\", x))","are in the vColumn. You can write the following list:",": Fills the vColumn outliers using the input method. \"\"\"","be empty in case of discretization using the method 'smart'.\"","the best splits when 'method' is set to 'smart'. A","elements. \"\"\" if \"agg\" not in kwargs: query = \"SELECT","= self.parent.format_colnames(ts) if by: self.parent.are_namecols_in(by) by = self.parent.format_colnames(by) from verticapy.plot","unique : cardinality (count distinct) var : variance Other aggregations","FROM {} GROUP BY {};\".format( by[0], fun, self.alias, self.parent.__genSQL__(), by[0]","of the vColumn record by an input value. The vColumn","else \" WHERE {} = '{}'\".format( bin_spatial_to_str(self.category(), self.alias), category, )","# VerticaPy is a Python library with scikit-like functionality for","axes object See Also -------- vDataFrame.plot : Draws the time",") ) # ---# def apply_fun(self, func: str, x: float","WHEN vColumn = argv[2 * i] THEN argv[2 * i","[list]), (\"order_by\", order_by, [list]), ] ) method = method.lower() self.parent.are_namecols_in([elem","optional Number representing the outliers threshold. Values lesser than quantile(alpha)","float])]) if self.isdate(): return self.apply(func=\"TIMESTAMPADD(SECOND, -({}), {})\".format(x, \"{}\")) else: return","\"std\" ] elif method == \"minmax\": self.catalog[elem] = (sauv[elem] -","query = \"SELECT {} FROM (SELECT {}, ROW_NUMBER() OVER (ORDER","limit = 0 limit = \" LIMIT {}\".format(limit) else: limit","for sublist in query_result for item in sublist] # ---#","optional Input End Date. For example, time = '03-11-1993' will","WHERE {} < {}) UNION ALL (SELECT AVG({}) FROM vdf_table","name, new_vColumn) setattr(self.parent, name[1:-1], new_vColumn) self.parent._VERTICAPY_VARIABLES_[\"columns\"] += [name] self.parent.__add_to_history__( \"[Add","= False, ): \"\"\" --------------------------------------------------------------------------- Encodes the vColumn with the","from verticapy.plot import hist return hist(self, method, of, max_cardinality, nbins,","agg = aggregate # ---# def apply(self, func: str, copy_name:","== []: if fun == \"AVG\": val = self.avg() elif","to discretize the vColumn. auto : Uses method 'same_width' for","Clips the vColumn by transforming the values lesser than the","= 2): \"\"\" --------------------------------------------------------------------------- Applies a default function to the","self.parent # ---# def geo_plot(self, *args, **kwargs): \"\"\" --------------------------------------------------------------------------- Draws","{}) {}\".format( self.parent.__genSQL__(), \" UNION ALL \".join(query) ) title =","be transformed. Parameters ---------- pat: str regular expression. Returns -------","float = 0, pie_type: str = \"auto\", ax=None, **style_kwds, ):","return result except: model.drop() raise # ---# def describe( self,","\".format(self.alias) if (dropna) else \" \" result = executeSQL( \"SELECT","float vColumn memory usage (byte) See Also -------- vDataFrame.memory_usage :",": Returns the vColumn most occurent elements. \"\"\" if \"agg\"","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","= sauv[\"count\"] self.catalog[\"percent\"] = ( 100 * sauv[\"count\"] / self.parent.shape()[0]","empty, an optimized h will be computed. ax: Matplotlib axes","\"{}\", h, h, \"{}\", h, h, h, floor_end ), \"varchar\",","\"\"\" if self.category() in [\"date\", \"float\"]: warning_message = ( \"label_encode","itself and the values higher than the upper bound to","selecting it in the final generated SQL code. Note: Dropping","= catalog[elem] # ---# def __getitem__(self, index): if isinstance(index, slice):","null, 1 otherwise. expr: str, optional SQL expression. by: list,","self.count() if (method == \"mode\") and (val == None): val","str/float/int vColumn nth most occurent element. See Also -------- vDataFrame.aggregate","vColumns based on an aggregation. \"\"\" check_types( [ (\"by\", by,","\\/ # / # VerticaPy is a Python library with","xlim: xmin = self.min() xmax = self.max() else: xmin, xmax","self.parent[copy_name].transformations += [(func, ctype, category)] self.parent[copy_name].catalog = self.catalog self.parent.__add_to_history__( \"[Apply]:","if return_trans: return \"({} - {}) / {}({})\".format( self.alias, avg,","new category : 'Others'. cat_priority: list, optional List of the","trans += \"WHEN {} BETWEEN {} AND {} THEN '[{};{}]'","nth most occurent element. Parameters ---------- dropna: bool, optional If","rose, ax=None, **style_kwds, ) # ---# def plot( self, ts:","is greater than November 1993 the 3rd. area: bool, optional","\"{}\\nError when applying the func 'x -> {}' to '{}'\".format(","|_)(_|(_|| \\_/|_|(_||| # / # ____________ ______ # / __","---# def isbool(self): \"\"\" --------------------------------------------------------------------------- Returns True if the vColumn","\"bfill\", \"backfill\"): assert order_by, ParameterError( \"If the method is in","ASC LIMIT 1\".format( self.alias, self.alias, self.parent.__genSQL__(), where, self.alias, n ),","cardinality is returned. By setting this parameter to False, the","For example to apply the function: x -> x^2 +","the absolute value of the record is greater than the","ctype = \"float\", \"float\" elif method == \"0ifnull\": category, ctype","self.apply(func=\"SUBSTR({}, {}, {})\".format(\"{}\", start, step)) # ---# def sub(self, x:","[(expr, \"int\", \"int\")] self.parent.__update_catalog__(erase=True, columns=[self.alias]) self.catalog[\"count\"] = self.parent.shape()[0] self.catalog[\"percent\"] =","plot. gaussian : Gaussian kernel. logistic : Logistic kernel. sigmoid","range(max_floor): self.transformations += [(\"{}\", self.ctype(), self.category())] self.transformations += [ (\"AVG({})","|| ''\", \"varchar\", \"text\") if (self.isnum() and method == \"same_freq\")","\"\") + prefix_sep.replace('\"', \"_\") if not (prefix) else prefix.replace('\"', \"_\")","0 for column in all_cols: try: if (quote_ident(column) in func)","self.alias, self.alias, table ) result = executeSQL( query, title=\"Different aggregations","1) and (self.parent[by[0]].nunique() < 50): try: result = executeSQL( \"SELECT","nbins, h, ax=ax, **style_kwds) # ---# def iloc(self, limit: int","product # ---# def quantile(self, x: float, approx: bool =","APPROXIMATE_PERCENTILE ({3}{4} USING PARAMETERS percentile = 0.5) AS 'approx_50%', APPROXIMATE_PERCENTILE","date like (date, datetime, timestamp...) or numerical. q: tuple, optional",": Logistic kernel. sigmoid : Sigmoid kernel. silverman : Silverman","mad, med = self.aggregate([\"mad\", \"approx_median\"]).values[self.alias] mad *= 1.4826 if mad","stddev = self.aggregate([\"avg\", \"std\"]).values[self.alias] if stddev == 0: warning_message =","\"\"\" --------------------------------------------------------------------------- Returns the vColumn expected store usage (unit: b).","See Also -------- vDataFrame[].ctype : Returns the vColumn database type.","than the upper bound to the upper bound itself. Parameters","sigmoid : Sigmoid kernel. silverman : Silverman kernel. nbins: int,","vColumn will be transformed. Parameters ---------- field: str The field","vDataFrame.applymap : Applies a function to all the vColumns. vDataFrame.eval","elem in sauv: self.catalog[elem] = sauv[elem] return self.parent # ---#","lp, rp = \"\", \"\" for category in cat: tmp_query","vColumns using the input method. Parameters ---------- method: str, optional","elem: if \"percent\" in elem: self.catalog[elem] = sauv[elem] elif elem","using a time series rule. Parameters ---------- length: int Slice","number of nbins used for the discretization (must be >","generated. include_lowest: bool, optional If set to True, the lowest","vColumn can be seen as one column of that relation.","check_types([(\"limit\", limit, [int, float]), (\"offset\", offset, [int, float])]) if offset","--------------------------------------------------------------------------- Drops outliers in the vColumn. Parameters ---------- threshold: float,","of {} partitioned by {}.\".format( numcol, self.alias ) values =","compute other vColumns. Parameters ---------- add_history: bool, optional If set",": Sum of the vColumn 'of'. q% : q Quantile","FROM {}{}GROUP BY {} ORDER BY _verticapy_cnt_ DESC LIMIT {})","the vColumn using an input 'quantile'. Parameters ---------- x: float","to compute the aggregation. h: int/float/tuple, optional Interval width of","expression is in each of the vColumn records. The vColumn","vDataFrame input aggregations. \"\"\" check_types( [ (\"method\", method, [\"auto\", \"numerical\",","will represent the number of seconds, otherwise it will represent","{} DESC LIMIT {}\".format( self.parent.__genSQL__(), self.alias, self.alias, n ) title","method == \"smart\" ): n = len(result) trans = \"(CASE","bool = True): \"\"\" --------------------------------------------------------------------------- Aggregates the vColumn using an","> 1) or (self.category() == \"float\"): trans = ( \"'['","number ln : natural logarithm log : logarithm log10 :","self.alias, self.alias, self.alias, self.alias, table ) result = executeSQL( query,","vColumn using 'unique' (cardinality). Parameters ---------- approx: bool, optional If","), \"varchar\", \"text\", ) elif self.isnum() and method == \"same_freq\":","drop(self, add_history: bool = True): \"\"\" --------------------------------------------------------------------------- Drops the vColumn","variable must be composed of two flower brackets {}. For","vColumn category is date. vDataFrame[].isnum : Returns True if the","kurtosis : kurtosis jb : Jarque-Bera index mad : median","of the vColumn. vDataFrame[].str_replace : Replaces the regular expression matches","executeSQL( query, title=\"Computing the top{} categories of {}.\".format( k if","/ uuid / undefined Returns ------- str vColumn category. See","the aggregation. h: int/float/tuple, optional Interval width of the vColumns","only available for categorical variables.\" ) warnings.warn(warning_message, Warning) else: distinct_elements","be date like (date, datetime, timestamp...) or numerical. q: tuple,","= 0.9) AS 'approx_90%', MAX({3}{4}) AS max FROM vdf_table\"\"\".format( category,","See Also -------- vDataFrame[].tail : Returns the a part of","len(all_new_features), conj, \", \".join(all_new_features) ) + \".\" ) return self.parent","Returns a part of the vColumn (delimited by an offset","the distinct categories of the vColumn. Returns ------- list Distinct","not (isinstance(val, Iterable)): val = [val] val += list(args) check_types([(\"val\",","str = \"\", prefix_sep: str = \"_\", drop_first: bool =","the vDataFrame Global Outliers. \"\"\" if isinstance(by, str): by =","regular expression is in each of the vColumn records. The","function's performance can drastically decrease. Returns ------- int vColumn cardinality","[ ( \"func\", func, [ \"abs\", \"acos\", \"asin\", \"atan\", \"cbrt\",","self.alias, kwargs[\"agg\"], self.parent.__genSQL__(), self.alias, ) query_result = executeSQL( query=query, title=\"Computing","bool = False, ): \"\"\" --------------------------------------------------------------------------- Discretizes the vColumn using","---------- argv: object Any amount of expressions. The expression generated","\"-.\\ \\ # \\ \\ \\'/ \\ \\ \\____ \\","None: mean_alpha = \"NULL\" self.apply( func=\"(CASE WHEN {} < {}","vColumn. Returns ------- list Distinct caterogies of the vColumn. See","for column in order_by]) new_column = \"COALESCE({}, LAST_VALUE({} IGNORE NULLS)","(\"RFmodel_params\", RFmodel_params, [dict]), (\"return_enum_trans\", return_enum_trans, [bool]), (\"h\", h, [int, float]),","h, h, floor_end ), \"varchar\", \"text\", ) else: trans =","the vColumn. Parameters ---------- n: int, optional Offset. Returns -------","partitioned by {}.\".format( numcol, self.alias ) values = to_tablesample(query, title=title).values","DESC LIMIT {1})\"\"\".format( self.alias, max_cardinality ) if distinct_count > max_cardinality:","Returns the vColumn database type. \"\"\" return self.transformations[-1][2] # ---#","\"\"\" --------------------------------------------------------------------------- Returns the head of the vColumn. Parameters ----------","to_tablesample(query, title=title) # ---# def numh(self, method: str = \"auto\"):","\"backfill\"): assert order_by, ParameterError( \"If the method is in ffill|pad|bfill|backfill","1\".format( new_column.format(self.alias), self.parent.__genSQL__() ), print_time_sql=False, ) except: new_column = \"COALESCE({},","purpose. Returns ------- vDataFrame self.parent See Also -------- vDataFrame.outliers :","{} was discretized.\".format(self.alias) ) return self.parent # ---# def distinct(self,","length, unit.upper(), start_or_end ) ) # ---# def spider( self,","was deleted from the vDataFrame.\".format(self.alias) ) return parent # ---#","vDataFrame of the search. See Also -------- vDataFrame.isin : Looks","_verticapy_cnt_ DESC LIMIT {}) VERTICAPY_SUBTABLE ORDER BY _verticapy_cnt_ ASC LIMIT","(PARTITION BY {})\".format( self.alias, \", \".join(by) ), ) else: avg,","int = 10): \"\"\" --------------------------------------------------------------------------- Returns the n largest vColumn","1993 the 3rd. end_date: str / date, optional Input End","def nlargest(self, n: int = 10): \"\"\" --------------------------------------------------------------------------- Returns the","topk most frequent categories and merge the other into one","best_h = max(math.floor(best_h), 1) return best_h # ---# def nunique(self,","return_enum_trans=True, )[0].replace(\"{}\", self.alias) query = \"SELECT {} AS {}, {}","func=\"REGEXP_COUNT({}, '{}')\".format(\"{}\", pat.replace(\"'\", \"''\")) ) # ---# def str_extract(self, pat:","Parameters ---------- func: str Function to use to transform the","---# def memory_usage(self): \"\"\" --------------------------------------------------------------------------- Returns the vColumn memory usage.","0ifnull : 0 when the vColumn is null, 1 otherwise.","= verticapy.options[\"temp_schema\"] if not (schema): schema = \"public\" tmp_view_name =","each of the vColumn records by an input value. vDataFrame[].str_slice","0.75), start_date: Union[str, datetime.datetime, datetime.date] = \"\", end_date: Union[str, datetime.datetime,","in result] ), ) executeSQL( \"SELECT {} FROM {} LIMIT","verticapy.options[\"print_info\"]: print(\"Nothing was filled.\") self.transformations = [elem for elem in","{}))\".format( \"{}\", fun, \"{}\", \", \".join(by) ) elif method in",") ax.set_xlabel(self.alias) return ax kernel = kernel.lower() from verticapy.learn.neighbors import","if return_trans: return \"({} - {}) / {}({} - {})\".format(",": median absolute deviation max : maximum mean : average","self.parent.__get_last_order_by__(), limit, offset, ), title=title, ) tail.count = self.parent.shape()[0] tail.offset","/ / # \\_______/ / / # ______ / /","] if mean_alpha == None: mean_alpha = \"NULL\" if mean_1_alpha","\"0ifnull\": category, ctype = \"int\", \"bool\" else: category, ctype =","= method.lower() if method == \"auto\": pre_comp = self.parent.__get_catalog_value__(self.alias, \"numh\")","\\__| \\ \\_____\\ \\ \\_____\\ \\ \\_____\\ \\ \\_____\\ \\","self.catalog[\"min\"] = 0 self.catalog[\"max\"] = 1 self.parent.__add_to_history__( \"[Normalize]: The vColumn","result[idx][0] = ( \"NULL\" if (elem[0] == None) else \"'{}'\".format(str(elem[0]).replace(\"'\",","= \"COALESCE({}, {}({}) OVER (PARTITION BY {}))\".format( \"{}\", fun, \"{}\",","tablesample(values) # ---# def discretize( self, method: str = \"auto\",","field: str The field to extract. It must be one","vColumn using the mean encoding of a response. \"\"\" import"],"string":"[\n \"parent vDataFrame is modified. Attributes ---------- alias, str : vColumn\",\n \"\\\"DECODE({}, '{}', 1, 0)\\\".format( \\\"{}\\\", str(distinct_elements[k]).replace(\\\"'\\\", \\\"''\\\") ) transformations =\",\n \"if (nullifzero) else \\\"\\\", cmax, cmin, ), \\\"float\\\", \\\"float\\\", )\",\n \"One-Hot Encoding. \\\"\\\"\\\" check_types([(\\\"response\\\", response, [str])]) self.parent.are_namecols_in(response) response = self.parent.format_colnames(response)\",\n \"between the max and the min sem : standard error\",\n \"of its affiliates. # Licensed under the Apache License, Version\",\n \"in (\\\"float\\\", \\\"int\\\"), TypeError( \\\"The column 'numcol' must be numerical\\\"\",\n \"OVER (PARTITION BY {})\\\".format( self.alias, \\\", \\\".join(by) ), ) else:\",\n \"= \\\"(\\\", \\\")\\\" else: lp, rp = \\\"\\\", \\\"\\\" for\",\n \"to the input vColumn. \\\"\\\"\\\" check_types( [ (\\\"breaks\\\", breaks, [list]),\",\n \"---# def density( self, by: str = \\\"\\\", bandwidth: float\",\n \"if the vColumn is boolean. See Also -------- vDataFrame[].isdate :\",\n \"vColumn database type. \\\"\\\"\\\" return self.transformations[-1][2] # ---# def clip(self,\",\n \"the slicing. step: int Size of the slicing. Returns -------\",\n \"{} AS verticapy_agg FROM {} WHERE {} IS NOT NULL\",\n \"(Standard Deviation). Returns ------- float std See Also -------- vDataFrame.aggregate\",\n \"this issue.\\\" ) self.add_copy(new_name) parent = self.drop(add_history=False) parent.__add_to_history__( \\\"[Rename]: The\",\n \"to True, the approximate quantile is returned. By setting this\",\n \"self.aggregate(func=[prefix + \\\"{}%\\\".format(x * 100)]).values[self.alias][ 0 ] # ---# def\",\n \"\\\"exp\\\", \\\"floor\\\", \\\"ln\\\", \\\"log\\\", \\\"log10\\\", \\\"mod\\\", \\\"pow\\\", \\\"round\\\", \\\"sign\\\", \\\"sin\\\",\",\n \"h = round(h, 4) elif h > 0.000001: h =\",\n \"return parent # ---# def round(self, n: int): \\\"\\\"\\\" ---------------------------------------------------------------------------\",\n \"[0, 1], TypeError( \\\"vColumn {} must be binary to use\",\n \"in range(max_floor): self.transformations += [(\\\"{}\\\", self.ctype(), self.category())] self.transformations += [(func,\",\n \"[(\\\"{}\\\", self.ctype(), self.category())] self.transformations += [ (\\\"AVG({}) OVER (PARTITION BY\",\n \"title=\\\"Different aggregations to compute the optimal h.\\\", method=\\\"fetchrow\\\", ) count,\",\n \"object See Also -------- vDataFrame.donut : Draws the donut chart\",\n \"cotangent exp : exponential function floor : value down to\",\n \"def abs(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Applies the absolute value function to\",\n \"of nbins will be computed. h: float, optional Interval width\",\n \"slower if the vDataFrame has been transformed multiple times, so\",\n \"LIMIT 1\\\".format( avg, stddev, self.parent.__genSQL__() ), print_time_sql=False, ) except: avg,\",\n \"result[i - 1], result[i] ) trans += \\\" ELSE NULL\",\n \"input vColumn. \\\"\\\"\\\" check_types([(\\\"n\\\", n, [int, float])]) return self.apply(func=\\\"ROUND({}, {})\\\".format(\\\"{}\\\",\",\n \"value_counts(self, k: int = 30): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns the k\",\n \"The expression generated will look like: even: CASE ... WHEN\",\n \"str): \\\"\\\"\\\" --------------------------------------------------------------------------- Renames the vColumn by dropping the current\",\n \"\\\"\\\"\\\" --------------------------------------------------------------------------- Replaces the regular expression matches in each of\",\n \"if not xlim: xmin = self.min() xmax = self.max() else:\",\n \"\\\"floor\\\", \\\"ln\\\", \\\"log\\\", \\\"log10\\\", \\\"mod\\\", \\\"pow\\\", \\\"round\\\", \\\"sign\\\", \\\"sin\\\", \\\"sinh\\\",\",\n \"std robust_zscore : Normalization using the Robust Z-Score (median and\",\n \"Applies the absolute value function to the input vColumn. Returns\",\n \"or not (isinstance(cat_priority, Iterable)): cat_priority = [cat_priority] check_types( [ (\\\"by\\\",\",\n \"- alpha], [self.alias]) .transpose() .values[self.alias] ) self.parent.filter( \\\"({} BETWEEN {}\",\n \"from the vDataFrame. Dropping a vColumn means simply not selecting\",\n \"final_transformation = [ ( \\\"({} - {}) / {}({} -\",\n \"FROM {}{} GROUP BY {} ORDER BY _verticapy_cnt_ DESC {}\\\".format(\",\n \"0: index_start += self.parent.shape()[0] if isinstance(index_stop, int): if index_stop <\",\n \"of the vColumn records by an input value. vDataFrame[].str_slice :\",\n \"1] ... END odd : CASE ... WHEN vColumn =\",\n \"---# def boxplot( self, by: str = \\\"\\\", h: float\",\n \"vDataFrame self.parent See Also -------- vDataFrame.astype : Converts the vColumns\",\n \"+= [\\\"\\\"] result.values[\\\"woe\\\"] += [\\\"\\\"] result.values[\\\"iv\\\"] += [sum(result[\\\"iv\\\"])] return result\",\n \"name: str Name of the copy. Returns ------- vDataFrame self.parent\",\n \"set to True, the approximate quantile is returned. By setting\",\n \"and method == \\\"smart\\\": schema = verticapy.options[\\\"temp_schema\\\"] if not (schema):\",\n \"query = \\\"SELECT {} AS {} FROM {} WHERE {}\",\n \"[order_by] check_types( [ ( \\\"method\\\", method, [ \\\"auto\\\", \\\"mode\\\", \\\"0ifnull\\\",\",\n \"total > 1 else \\\" was \\\" if verticapy.options[\\\"print_info\\\"]: print(\\\"{}\",\n \"if not (isinstance(index_start, int)): index_start = 0 if index_start <\",\n \"information. Parameters ---------- k: int, optional Number of most occurent\",\n \"ctype, category)] self.parent[copy_name].catalog = self.catalog self.parent.__add_to_history__( \\\"[Apply]: The vColumn '{}'\",\n \"start_date: Union[str, datetime.datetime, datetime.date] = \\\"\\\", end_date: Union[str, datetime.datetime, datetime.date]\",\n \"stddev = std # ---# def store_usage(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns\",\n \"result of using previously the method on the vColumn \\\"\",\n \"[], ax=None, **style_kwds, ): \\\"\\\"\\\" --------------------------------------------------------------------------- Draws the box plot\",\n \"+= [name] conj = \\\"s were \\\" if len(all_new_features) >\",\n \"License for the specific language governing permissions and # limitations\",\n \"vColumn categories. Parameters ---------- response: str Response vColumn. Returns -------\",\n \"using a user-defined encoding. Parameters ---------- argv: object Any amount\",\n \"dtype ) ) return self.parent except Exception as e: raise\",\n \"more information, see utilities.tablesample. See Also -------- vDataFrame[].nsmallest : Returns\",\n \"fd else: best_h = max(sturges, fd) self.parent.__update_catalog__({\\\"index\\\": [\\\"numh\\\"], self.alias: [best_h]})\",\n \"{} < {} THEN {} WHEN {} > {} THEN\",\n \"result[\\\"std\\\"][0], threshold ) ) else: p_alpha, p_1_alpha = ( self.parent.quantile([alpha,\",\n \"vColumn {}\\\\n{} feature{}created: {}\\\".format( self.alias, len(all_new_features), conj, \\\", \\\".join(all_new_features) )\",\n \"from verticapy.errors import * ## # # __ __ ______\",\n \"'avg' (Average). Returns ------- float average See Also -------- vDataFrame.aggregate\",\n \"= \\\"SELECT {}, ord, non_events, events, non_events / NULLIFZERO(SUM(non_events) OVER\",\n \"is date, False otherwise. Returns ------- bool True if the\",\n \"\\\"{}%\\\".format(x * 100)]).values[self.alias][ 0 ] # ---# def range_plot( self,\",\n \"[name] self.parent.__add_to_history__( \\\"[Add Copy]: A copy of the vColumn {}\",\n \"set to 'smart'. A RF Regressor will be trained if\",\n \"argv: object Any amount of expressions. The expression generated will\",\n \"compute the optimal h. auto : Combination of Freedman Diaconis\",\n \"return ax kernel = kernel.lower() from verticapy.learn.neighbors import KernelDensity schema\",\n \"will be transformed. Parameters ---------- start: int Start of the\",\n \"self.parent[by].distinct() for idx, column in enumerate(columns): param = {\\\"color\\\": colors[idx\",\n \"records. vDataFrame[].str_count : Computes the number of matches for the\",\n \"can make the vDataFrame \\\"heavier\\\" if it is used to\",\n \"Matplotlib axes object See Also -------- vDataFrame[].hist : Draws the\",\n \"|| '', COUNT(*) FROM vdf_table GROUP BY {0} ORDER BY\",\n \"float = 0.05, ): \\\"\\\"\\\" --------------------------------------------------------------------------- Fills the vColumns outliers\",\n \"the copy. Returns ------- vDataFrame self.parent See Also -------- vDataFrame.eval\",\n \"\\\\_\\\\\\\\\\\"\\\\_\\\\ # \\\\/_/ \\\\/_____/ \\\\/_____/ \\\\/_____/ \\\\/_____/ \\\\/_/ \\\\/_/ \\\\/_/\",\n \"vColumn. vDataFrame[].extract : Extracts the regular expression in each record\",\n \"# (c) Copyright [2018-2022] Micro Focus or one of its\",\n \"value. winsorize : Clips the vColumn using as lower bound\",\n \"8, cat_priority: list = [], ax=None, **style_kwds, ): \\\"\\\"\\\" ---------------------------------------------------------------------------\",\n \"\\\"same_width\\\", \\\"same_freq\\\", \\\"topk\\\"], ), (\\\"return_enum_trans\\\", return_enum_trans, [bool]), ] ) method\",\n \"LIMIT 1\\\".format( self.alias, self.alias, self.parent.__genSQL__(), where, self.alias, n ), title=\\\"Computing\",\n \"self.alias ), method=\\\"fetchall\\\", ) ] if mean_alpha == None: mean_alpha\",\n \"\\\"categorical\\\"): result = self.aggregate([\\\"count\\\", \\\"min\\\", \\\"max\\\"]) index = result.values[\\\"index\\\"] result\",\n \"verticapy.plot import bar return bar(self, method, of, max_cardinality, nbins, h,\",\n \"== \\\"smart\\\" ): n = len(result) trans = \\\"(CASE \\\"\",\n \"{}, {})\\\".format(\\\"{}\\\", start, step)) # ---# def sub(self, x: float):\",\n \"[ (\\\"by\\\", by, [str]), (\\\"max_cardinality\\\", max_cardinality, [int, float]), (\\\"h\\\", h,\",\n \"[float(round(item[2], 3)) for item in result], } return tablesample(values) #\",\n \"\\\"\\\"\\\" return self.describe(method=\\\"categorical\\\", max_cardinality=k) # ---# def var(self): \\\"\\\"\\\" ---------------------------------------------------------------------------\",\n \"def density( self, by: str = \\\"\\\", bandwidth: float =\",\n \"if method in (\\\"mean\\\", \\\"median\\\") or isinstance(val, float): category, ctype\",\n \") p_alpha, p_1_alpha = executeSQL( query=query, title=\\\"Computing the quantiles of\",\n \"quantile. For example: 0.25 represents Q1. approx: bool, optional If\",\n \"range(1, n): trans += \\\"WHEN {} BETWEEN {} AND {}\",\n \"Returns ------- bool True if the vColumn is numerical. See\",\n \"not in ([0, 1], [1, 0]) or self.isbool(): all_new_features =\",\n \"return self.parent.aggregate(func=func, columns=[self.alias]).transpose() agg = aggregate # ---# def apply(self,\",\n \"{2} AS percent, AVG({3}{4}) AS mean, STDDEV({3}{4}) AS std, MIN({3}{4})\",\n \"\\\"winsorize\\\", threshold: float = 4.0, use_threshold: bool = True, alpha:\",\n \"information, see utilities.tablesample. See Also -------- vDataFrame[].nlargest : Returns the\",\n \"not (\\\"figsize\\\" in kwargs): kwargs[\\\"figsize\\\"] = (14, 10) return self.parent[columns].to_geopandas(self.alias).plot(*args,\",\n \"\\\"\\\"\\\" check_types([(\\\"dtype\\\", dtype, [str])]) try: query = \\\"SELECT {}::{} AS\",\n \") elif method == \\\"zscore\\\": self.catalog[elem] = (sauv[elem] - sauv[\\\"mean\\\"])\",\n \"vDataFrame input aggregations. \\\"\\\"\\\" check_types([(\\\"dropna\\\", dropna, [bool]), (\\\"n\\\", n, [int,\",\n \"the vDataFrame input aggregations. \\\"\\\"\\\" return self.aggregate([\\\"sem\\\"]).values[self.alias][0] # ---# def\",\n \"== \\\"median\\\") else \\\"AVG\\\" if by == []: if fun\",\n \"\\\"COALESCE({}, {})\\\".format(\\\"{}\\\", expr) elif method == \\\"0ifnull\\\": new_column = \\\"DECODE({},\",\n \"ZEROIFNULL(SUM(LENGTH({}::varchar))) FROM {}\\\".format( bin_spatial_to_str(self.category(), self.alias), self.parent.__genSQL__(), ), title=\\\"Computing the Store\",\n \"of the search. See Also -------- vDataFrame.isin : Looks if\",\n \"/ {}) * {} + {}{}) || ']'\\\".format( \\\"{}\\\", h,\",\n \"method == \\\"zscore\\\": self.catalog[elem] = (sauv[elem] - sauv[\\\"mean\\\"]) / sauv[\",\n \": Returns True if the vColumn is boolean. vDataFrame[].isnum :\",\n \"WHEN ({} BETWEEN {} AND {}) THEN {} ELSE NULL\",\n \"dict, optional Dictionary of the Random Forest model parameters used\",\n \"\\\"float\\\", ) ] elif method == \\\"robust_zscore\\\": if n >\",\n \"[int, float]), (\\\"response\\\", response, [str]), (\\\"nbins\\\", nbins, [int, float]), (\",\n \"if use_threshold: result = self.aggregate(func=[\\\"std\\\", \\\"avg\\\"]).transpose().values self.parent.filter( \\\"ABS({} - {})\",\n \"# ---# def isbool(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns True if the\",\n \"method. Parameters ---------- method: str, optional The describe method. auto\",\n \"/ (1.4826 * mad) minmax : Normalization using the MinMax\",\n \"None else \\\"NULL\\\", elem[2] if elem[2] != None else \\\"NULL\\\",\",\n \"float = 1.0, kernel: str = \\\"gaussian\\\", nbins: int =\",\n \"check_types([(\\\"val\\\", val, [list])]) val = {self.alias: val} return self.parent.isin(val) #\",\n \"\\\"(CASE WHEN {} IN ({}) THEN {} || '' ELSE\",\n \"'', COUNT(*) FROM vdf_table GROUP BY {0} ORDER BY COUNT(*)\",\n \"[self.alias] check = True if len(args) > 0: column =\",\n \"categories of {}.\\\".format(self.alias), method=\\\"fetchall\\\", ) return [item for sublist in\",\n \"str): method = method.lower() check_types( [ (\\\"method\\\", method, [\\\"winsorize\\\", \\\"null\\\",\",\n \"OF ANY KIND, either express or implied. # See the\",\n \"1 then this method will return the mode of the\",\n \"the vColumn. vDataFrame[].extract : Extracts the regular expression in each\",\n \"in result if elem[1] != None ] ), ) cmax\",\n \"Returns ------- ax Matplotlib axes object \\\"\\\"\\\" columns = [self.alias]\",\n \"date. See Also -------- vDataFrame[].isbool : Returns True if the\",\n \"records are in the vDataFrame. \\\"\\\"\\\" if isinstance(val, str) or\",\n \"= self.distinct() expr = [\\\"DECODE({}\\\"] text_info = \\\"\\\\n\\\" for k\",\n \"the vColumn by the input element. Parameters ---------- x: float\",\n \"\\\"SELECT split_value FROM (SELECT split_value, MAX(weighted_information_gain) FROM ({}) VERTICAPY_SUBTABLE WHERE\",\n \"= False, ): \\\"\\\"\\\" --------------------------------------------------------------------------- Discretizes the vColumn using the\",\n \"verticapy.options[\\\"print_info\\\"]: print(\\\"{} element{}filled.\\\".format(total, conj)) self.parent.__add_to_history__( \\\"[Fillna]: {} {} missing value{}\",\n \"---# def category(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns the category of the\",\n \"== \\\"zscore\\\": self.catalog[\\\"mean\\\"] = 0 self.catalog[\\\"std\\\"] = 1 elif method\",\n \"str(func) check_types([(\\\"func\\\", func, [str]), (\\\"copy_name\\\", copy_name, [str])]) try: try: ctype\",\n \"\\\" if len(all_new_features) > 1 else \\\" was \\\" self.parent.__add_to_history__(\",\n \"kurtosis # ---# def label_encode(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Encodes the vColumn\",\n \": trigonometric sine sinh : hyperbolic sine sqrt : arithmetic\",\n \"from verticapy.plot import pie return pie( self, method, of, max_cardinality,\",\n \"= \\\"\\\", end_date: Union[str, datetime.datetime, datetime.date] = \\\"\\\", plot_median: bool\",\n \"float], ), ( \\\"end_date\\\", end_date, [str, datetime.datetime, datetime.date, int, float],\",\n \"self.transformations = ( parent, alias, [elem for elem in transformations],\",\n \"(WOE) Table. It tells the predictive power of an independent\",\n \"= \\\"(SELECT DATEDIFF('second', '{}'::timestamp, {}) AS {} FROM {}) VERTICAPY_OPTIMAL_H_TABLE\\\".format(\",\n \"new_name, [str])]) old_name = quote_ident(self.alias) new_name = new_name.replace('\\\"', \\\"\\\") assert\",\n \"method.lower() self.parent.are_namecols_in([elem for elem in order_by] + by) by =\",\n \"vColumn has already the alias {new_name}.\\\\nBy changing the parameter 'new_name',\",\n \"--------------------------------------------------------------------------- Clips the vColumn by transforming the values lesser than\",\n \"of the vColumn. Returns ------- list Distinct caterogies of the\",\n \"columns=[self.alias]).transpose() agg = aggregate # ---# def apply(self, func: str,\",\n \"aad : average absolute deviation approx_unique : approximative cardinality count\",\n \"---------- name: str Name of the copy. Returns ------- vDataFrame\",\n \") # ---# def std(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn\",\n \"return self.apply( func=\\\"REGEXP_SUBSTR({}, '{}')\\\".format(\\\"{}\\\", pat.replace(\\\"'\\\", \\\"''\\\")) ) # ---# def\",\n \"vDataFrame.isin : Looks if some specific records are in the\",\n \"return_trans: return \\\"({} - {}) / ({})\\\".format(self.alias, med, mad) else:\",\n \"zscore|minmax\\\" warnings.warn(warning_message, Warning) return self mad, med = self.aggregate([\\\"mad\\\", \\\"approx_median\\\"]).values[self.alias]\",\n \"\\\"\\\" if (h > 1) or (self.category() == \\\"float\\\"): trans\",\n \"aggregations during the computation. cat_stats : Computes statistics of a\",\n \"= 0 THEN 0 ELSE ZEROIFNULL(LN(pt_non_events / NULLIFZERO(pt_events))) END AS\",\n \"AS iv FROM ({}) x ORDER BY ord\\\".format( self.alias, query,\",\n \"copy_name: str, optional If not empty, a copy will be\",\n \") stddev = \\\"DECODE({}, {}, NULL)\\\".format( by[0], \\\", \\\".join( [\",\n \"the vColumn with user defined Encoding. vDataFrame[].discretize : Discretizes the\",\n \"[\\\"\\\"] result.values[\\\"woe\\\"] += [\\\"\\\"] result.values[\\\"iv\\\"] += [sum(result[\\\"iv\\\"])] return result #\",\n \": Average of the vColumn 'of'. min : Minimum of\",\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:\",\n \"\\\\_\\\\ \\\\ \\\\ \\\\ \\\\-./\\\\ \\\\ \\\\ \\\\ \\\\-. \\\\\",\n \"result = ( self.parent.describe( method=\\\"numerical\\\", columns=[self.alias], unique=False ) .transpose() .values[self.alias]\",\n \"# ---# def isin(self, val: list, *args): \\\"\\\"\\\" --------------------------------------------------------------------------- Looks\",\n \"else: final_transformation = [ ( \\\"({} - {}) / {}({})\\\".format(\",\n \"= 4.0, use_threshold: bool = True, alpha: float = 0.05,\",\n \"= \\\"COALESCE({}, DECODE({}, {}, NULL))\\\".format( \\\"{}\\\", by[0], \\\", \\\".join( [\\\"{},\",\n \") assert not (self.parent.is_colname_in(name)), NameError( f\\\"A vColumn has already the\",\n \"same_width : Computes regular width bins. smart : Uses the\",\n \"BY {})\\\".format( self.alias, \\\", \\\".join(by) ), ) else: avg, stddev\",\n \"(SELECT * FROM {}) (SELECT AVG({}) FROM vdf_table WHERE {}\",\n \"+ [str(count)]) ) query = \\\"SELECT {} FROM (SELECT {},\",\n \"= self.parent.format_colnames(numcol) assert self.parent[numcol].category() in (\\\"float\\\", \\\"int\\\"), TypeError( \\\"The column\",\n \"0)\\\".format( \\\"{}\\\", str(distinct_elements[k]).replace(\\\"'\\\", \\\"''\\\") ) transformations = self.transformations + [(expr,\",\n \"= executeSQL( \\\"SELECT {}, MIN({}), MAX({}) FROM {} GROUP BY\",\n \"[list]), (\\\"labels\\\", labels, [list]), (\\\"include_lowest\\\", include_lowest, [bool]), (\\\"right\\\", right, [bool]),\",\n \"modified. Attributes ---------- alias, str : vColumn alias. catalog, dict\",\n \"For more information, see utilities.tablesample. See Also -------- vDataFrame[].describe :\",\n \"---------- breaks: list List of values used to cut the\",\n \"str = \\\"\\\", max_cardinality: int = 6, nbins: int =\",\n \"x: float): \\\"\\\"\\\" --------------------------------------------------------------------------- Adds the input element to the\",\n \"the different transformations. \\\"\\\"\\\" # # Special Methods # #\",\n \"median See Also -------- vDataFrame.aggregate : Computes the vDataFrame input\",\n \"Computes statistics of a numerical column for each vColumn category.\",\n \"\\\"SELECT {} FROM (SELECT {}, COUNT(*) AS _verticapy_cnt_ FROM {}{}GROUP\",\n \"ax Matplotlib axes object \\\"\\\"\\\" columns = [self.alias] check =\",\n \"of the slicing instead of the ceiling. Returns ------- vDataFrame\",\n \"records. For example, to check if Badr and Fouad are\",\n \"not use this file except in compliance with the License.\",\n \"\\\"cramer\\\": {}, \\\"biserial\\\": {}, \\\"regr_avgx\\\": {}, \\\"regr_avgy\\\": {}, \\\"regr_count\\\": {},\",\n \"self, method: str = \\\"winsorize\\\", threshold: float = 4.0, use_threshold:\",\n \"k of the 'topk' method. new_category: str, optional The name\",\n \"int(nbins))) assert nb != 0, Exception( \\\"Not enough values to\",\n \"Extracts a specific TS field from the vColumn (only if\",\n \"specific records are in the vDataFrame. \\\"\\\"\\\" if isinstance(val, str)\",\n \"self.alias, where, ) result = executeSQL( query=query, title=\\\"Computing the equal\",\n \"(\\\"float\\\", \\\"int\\\") # ---# def iv_woe(self, y: str, nbins: int\",\n \"'{}'.\\\".format( self.alias, method ) ) else: raise TypeError(\\\"The vColumn must\",\n \"display. offset: int, optional Number of elements to skip. Returns\",\n \") result = executeSQL( query=query, title=\\\"Computing the equal frequency histogram\",\n \"Modules # # Standard Python Modules import math, re, decimal,\",\n \"vColumns.\\\" ) assert len(breaks) >= 2, ParameterError( \\\"Length of parameter\",\n \"0: op1, close_l = \\\"<\\\", \\\"]\\\" if labels: label =\",\n \"val = self.mode(dropna=True) if val == None: warning_message = \\\"The\",\n \"op1, op2, close_l, close_r = \\\"<\\\", \\\"<=\\\", \\\"]\\\", \\\"]\\\" else:\",\n \"\\\"mean\\\"]), (\\\"alpha\\\", alpha, [int, float]), (\\\"use_threshold\\\", use_threshold, [bool]), (\\\"threshold\\\", threshold,\",\n \"list, optional List of the different transformations. Each transformation must\",\n \"(cardinality). Parameters ---------- approx: bool, optional If set to True,\",\n \"be slower if the vDataFrame has been transformed multiple times,\",\n \"expression. \\\"\\\"\\\" if isinstance(func, str_sql): func = str(func) check_types([(\\\"func\\\", func,\",\n \": Computes the vDataFrame input aggregations. \\\"\\\"\\\" return self.aggregate([\\\"min\\\"]).values[self.alias][0] #\",\n \"\\\"''\\\"), ), \\\"varchar\\\", \\\"text\\\", ) elif self.isnum() and method ==\",\n \"input aggregations. \\\"\\\"\\\" return self.aggregate([\\\"mad\\\"]).values[self.alias][0] # ---# def max(self): \\\"\\\"\\\"\",\n \"elif method in (\\\"ffill\\\", \\\"pad\\\", \\\"bfill\\\", \\\"backfill\\\"): assert order_by, ParameterError(\",\n \"using 'min' (Minimum). Returns ------- float/str minimum See Also --------\",\n \"# ---# def count(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using\",\n \"creation of correlated features. use_numbers_as_suffix: bool, optional Uses numbers as\",\n \"x, [int, float], (\\\"approx\\\", approx, [bool]))]) prefix = \\\"approx_\\\" if\",\n \"(dropna) else \\\" \\\" result = executeSQL( \\\"SELECT {} FROM\",\n \"the regular expression in each record of the vColumn. The\",\n \"gaussian : Gaussian kernel. logistic : Logistic kernel. sigmoid :\",\n \"0, \\\"max\\\": 1, \\\"count\\\": self.parent.shape()[0], \\\"percent\\\": 100.0, \\\"unique\\\": 2, \\\"approx_unique\\\":\",\n \"False, the function's performance can drastically decrease. Returns ------- int\",\n \"self.parent[response].isnum(), TypeError( \\\"The response column must be numerical to use\",\n \"str vColumn DB type. \\\"\\\"\\\" return self.transformations[-1][1].lower() dtype = ctype\",\n \"\\\"heavier\\\" if it is used to compute other vColumns. Parameters\",\n \") executeSQL( \\\"SELECT {}, {} FROM {} LIMIT 1\\\".format( avg,\",\n \"the k most occurent elements, how often they occur, and\",\n \"float, optional Interval width of the bar. If empty, an\",\n \"h. auto : Combination of Freedman Diaconis and Sturges. freedman_diaconis\",\n \"str = \\\"_\\\", drop_first: bool = True, use_numbers_as_suffix: bool =\",\n \"Weight Of Evidence (WOE) Table. It tells the predictive power\",\n \"ax=ax, **style_kwds, ) # ---# def product(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates\",\n \"limit: int = 5): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns the tail of\",\n \"= nb, [], [] while total < int(float(count / int(nbins)))\",\n \"gen_colors kwargs[\\\"color\\\"] = gen_colors()[0] if not (\\\"legend\\\" in kwargs): kwargs[\\\"legend\\\"]\",\n \"0 ELSE (pt_non_events - pt_events) * ZEROIFNULL(LN(pt_non_events / NULLIFZERO(pt_events))) END\",\n \"must be numerical\\\" ) cast = \\\"::int\\\" if (self.parent[numcol].isbool()) else\",\n \"sauv[\\\"count\\\"] self.catalog[\\\"percent\\\"] = ( 100 * sauv[\\\"count\\\"] / self.parent.shape()[0] )\",\n \"\\\"vColumn doesn't allow slicing having steps different than 1.\\\" )\",\n \"--------------------------------------------------------------------------- Returns the vColumn expected store usage (unit: b). Returns\",\n \"with a user defined Encoding. vDataFrame[].discretize : Discretizes the vColumn.\",\n \"\\\".join(query), nbins - 1 ) result = executeSQL( query=query, title=\\\"Computing\",\n \"(\\\"step\\\", step, [int, float])]) return self.apply(func=\\\"SUBSTR({}, {}, {})\\\".format(\\\"{}\\\", start, step))\",\n \"**style_kwds, ): \\\"\\\"\\\" --------------------------------------------------------------------------- Draws the Time Series of the\",\n \"BY {};\\\".format( by[0], fun, self.alias, self.parent.__genSQL__(), by[0] ) result =\",\n \"\\\"\\\"\\\" --------------------------------------------------------------------------- Computes the number of matches for the regular\",\n \"numerical to use a mean encoding\\\" ) max_floor = len(self.parent[response].transformations)\",\n \"\\\\ / / / # \\\\_______/ / / # ______\",\n \"Parameters ---------- pat: str regular expression. Returns ------- vDataFrame self.parent\",\n \"greater than the threshold it will be considered as an\",\n \"--------------------------------------------------------------------------- Returns the head of the vColumn. Parameters ---------- limit:\",\n \"store_usage # ---# def str_contains(self, pat: str): \\\"\\\"\\\" --------------------------------------------------------------------------- Verifies\",\n \"a mean encoding with {} as Response Column.\\\".format( self.alias, response\",\n \": Propagation of the first element (Constant Interpolation). mean :\",\n \"is greater than the threshold it will be considered as\",\n \"vDataFrame[].str_replace : Replaces the regular expression matches in each of\",\n \"The axes to plot on. **style_kwds Any optional parameter to\",\n \"to the power of another number round : rounds a\",\n \"--------------------------------------------------------------------------- Draws the pie chart of the vColumn based on\",\n \") setattr(self.parent, name, new_vColumn) setattr(self.parent, name[1:-1], new_vColumn) self.parent._VERTICAPY_VARIABLES_[\\\"columns\\\"] += [name]\",\n \"input method. Parameters ---------- method: str, optional The method to\",\n \"{} can not be converted to {}\\\".format( e, self.alias, dtype\",\n \"if self.category() == \\\"float\\\" else \\\"\\\" if index < 0:\",\n \"if ((is_date) and not (method == \\\"categorical\\\")) or ( method\",\n \"self.parent.are_namecols_in(by) by = self.parent.format_colnames(by) from verticapy.plot import ts_plot return ts_plot(\",\n \"and (val == None): val = self.mode(dropna=True) if val ==\",\n \"input method. \\\"\\\"\\\" check_types([(\\\"lower\\\", lower, [float, int]), (\\\"upper\\\", upper, [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__(),\",\n \"parameter 'numcol' must be a vDataFrame column if the method\",\n \"must be a list of at least one element to\",\n \"\\\"text\\\") if (self.isnum() and method == \\\"same_freq\\\") or ( self.isnum()\",\n \"will be slower if the vDataFrame has been transformed multiple\",\n \"median min : minimum mode : most occurent element percent\",\n \"xlim: tuple, optional Set the x limits of the current\",\n \"self.parent See Also -------- vDataFrame.astype : Converts the vColumns to\",\n \"vDataFrame.aggregate : Computes the vDataFrame input aggregations. \\\"\\\"\\\" return self.aggregate([\\\"avg\\\"]).values[self.alias][0]\",\n \"True, ): \\\"\\\"\\\" --------------------------------------------------------------------------- Discretizes the vColumn using the input\",\n \"k in range(max_floor): self.parent[copy_name].transformations += [ (\\\"{}\\\", self.ctype(), self.category()) ]\",\n \"example, time = '03-11-1993' will filter the data when 'ts'\",\n \"category(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns the category of the vColumn. The\",\n \"False ): \\\"\\\"\\\" --------------------------------------------------------------------------- Normalizes the input vColumns using the\",\n \"False, step: bool = False, ax=None, **style_kwds, ): \\\"\\\"\\\" ---------------------------------------------------------------------------\",\n \"has no mode (only missing values).\\\\nNothing was filled.\\\".format( self.alias )\",\n \"must be equal to the length of parameter 'labels' +\",\n \"str, optional Method to use to fill the vColumn outliers.\",\n \"check_types([(\\\"x\\\", x, [int, float])]) return self.apply(func=\\\"{} * ({})\\\".format(\\\"{}\\\", x)) #\",\n \"of {}.\\\".format( k if k > 0 else \\\"\\\", self.alias\",\n \"not (prefix) else prefix.replace('\\\"', \\\"_\\\") + prefix_sep.replace('\\\"', \\\"_\\\") ) n\",\n \"than November 1993 the 3rd. plot_median: bool, optional If set\",\n \"0, Exception( \\\"Not enough values to compute the Equal Frequency\",\n \"example, if n = 1 then this method will return\",\n \": Encodes the vColumn with One-Hot Encoding. vDataFrame[].label_encode : Encodes\",\n \"transformed with the func 'x -> {}'.\\\".format( self.alias.replace('\\\"', \\\"\\\"), func.replace(\\\"{}\\\",\",\n \"DESC LIMIT {}) VERTICAPY_SUBTABLE ORDER BY split_value::float\\\".format( \\\" UNION ALL\",\n \"[self.alias]).plot( ax=ax, **style_kwds ) model.drop() return result except: model.drop() raise\",\n \"\\\".join([quote_ident(column) + desc for column in order_by]) new_column = \\\"COALESCE({},\",\n \"# ---# def boxplot( self, by: str = \\\"\\\", h:\",\n \"for elem in by: if len(self.parent[elem].transformations) > max_floor: max_floor =\",\n \"self.transformations += [(\\\"{}\\\", self.ctype(), self.category())] self.transformations += [(new_column, ctype, category)]\",\n \"expression to replace. value: str, optional New value. Returns -------\",\n \"elements in the vColumn. Parameters ---------- n: int, optional Offset.\",\n \"different aggregations.\\\", method=\\\"fetchall\\\", ) for idx, elem in enumerate(result): result[idx][0]\",\n \"a bijection from the different categories to [0, n -\",\n \"check_types([(\\\"pat\\\", pat, [str])]) return self.apply( func=\\\"REGEXP_SUBSTR({}, '{}')\\\".format(\\\"{}\\\", pat.replace(\\\"'\\\", \\\"''\\\")) )\",\n \"[ (\\\"method\\\", method, [\\\"winsorize\\\", \\\"null\\\", \\\"mean\\\"]), (\\\"alpha\\\", alpha, [int, float]),\",\n \"License, Version 2.0 (the \\\"License\\\"); # You may not use\",\n \"vColumns outliers using the input method. Parameters ---------- method: str,\",\n \"SQL expression. by: list, optional vColumns used in the partition.\",\n \"== \\\"robust_zscore\\\": self.catalog[elem] = (sauv[elem] - sauv[\\\"approx_50%\\\"]) / ( 1.4826\",\n \"the vColumn with a user-specified rule. Parameters ---------- val: int/float/str,\",\n \"vDataFrame.eval : Evaluates a customized expression. \\\"\\\"\\\" check_types([(\\\"name\\\", name, [str])])\",\n \"partition_by, order_by_ts ) if method in (\\\"mean\\\", \\\"median\\\") or isinstance(val,\",\n \"[str, datetime.datetime, datetime.date]), (\\\"area\\\", area, [bool]), (\\\"step\\\", step, [bool]), ]\",\n \"the vColumn based on an aggregation. \\\"\\\"\\\" if isinstance(pie_type, str):\",\n \"distinct_elements not in ([0, 1], [1, 0]) or self.isbool(): all_new_features\",\n \"aad(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using 'aad' (Average Absolute\",\n \"--------------------------------------------------------------------------- Aggregates the vColumn using 'aad' (Average Absolute Deviation). Returns\",\n \": logarithm log10 : base 10 logarithm mod : remainder\",\n \"Uses the Gaussian distribution to identify outliers. After normalizing the\",\n \"query=query, title=\\\"Computing the quantiles of {}.\\\".format(self.alias), method=\\\"fetchrow\\\", ) if method\",\n \"offset. For example, if n = 1 then this method\",\n \"right: bool, optional How the intervals should be closed. If\",\n \"optional Uses the Gaussian distribution to identify outliers. After normalizing\",\n \"{} LIMIT 1\\\".format( cmax, cmin, self.parent.__genSQL__() ), print_time_sql=False, ) except:\",\n \"---# def mad(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using 'mad'\",\n \"using Random Forest.\\\", method=\\\"fetchall\\\", ) result = [elem[0] for elem\",\n \"10): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns the n smallest elements in the\",\n \"the regular expression is in each of the vColumn records.\",\n \"Draws the bar chart of the vColumn based on an\",\n \"\\\"<=\\\", \\\"<\\\", \\\"[\\\", \\\"[\\\" if idx == 0 and include_lowest:\",\n \"---# def kurtosis(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using 'kurtosis'.\",\n \"(\\\"breaks\\\", breaks, [list]), (\\\"labels\\\", labels, [list]), (\\\"include_lowest\\\", include_lowest, [bool]), (\\\"right\\\",\",\n \"end_date, plot_median, ax=ax, **style_kwds, ) # ---# def rename(self, new_name:\",\n \"check_types([(\\\"n\\\", n, [int, float])]) query = \\\"SELECT * FROM {}\",\n \"self.parent # ---# def nsmallest(self, n: int = 10): \\\"\\\"\\\"\",\n \"optional How the intervals should be closed. If set to\",\n \"encoding of a response. \\\"\\\"\\\" if self.category() in [\\\"date\\\", \\\"float\\\"]:\",\n \"the vColumn and it returns the new vDataFrame of the\",\n \"of the 'topk' method. new_category: str, optional The name of\",\n \"(\\\"approx\\\", approx, [bool]))]) prefix = \\\"approx_\\\" if approx else \\\"\\\"\",\n \"numbers as suffix instead of the vColumns categories. Returns -------\",\n \"input value. \\\"\\\"\\\" check_types([(\\\"start\\\", start, [int, float]), (\\\"step\\\", step, [int,\",\n \"self.catalog: total += sys.getsizeof(elem) return total # ---# def min(self):\",\n \"WEEK / YEAR Returns ------- vDataFrame self.parent See Also --------\",\n \"{\\\"index\\\": [\\\"top{}\\\".format(n)], self.alias: [top]} ) return top # ---# def\",\n \"it can be 'minute' 'hour'... start: bool, optional If set\",\n \"ctype(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns the vColumn DB type. Returns -------\",\n \"to return. Returns ------- tablesample An object containing the result.\",\n \"new vColumn to the vDataFrame by using an advanced analytical\",\n \"= skewness # ---# def slice(self, length: int, unit: str\",\n \"if verticapy.options[\\\"print_info\\\"]: print(\\\"The mean encoding was successfully done.\\\") return self.parent\",\n \"\\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using 'std' (Standard Deviation). Returns\",\n \"float / text / binary / spatial / uuid /\",\n \"Returns the n largest vColumn elements. \\\"\\\"\\\" check_types([(\\\"n\\\", n, [int,\",\n \") else: final_transformation = [ ( \\\"({} - {}) /\",\n \"to the offset. For example, if n = 1 then\",\n \"using the input list. Parameters ---------- breaks: list List of\",\n \"limit = \\\"\\\" query = \\\"(SELECT {} FROM {}{} OFFSET\",\n \"distribution to define the outliers. After normalizing the data (Z-Score),\",\n \"str regular expression. Returns ------- vDataFrame self.parent See Also --------\",\n \"---# def pie( self, method: str = \\\"density\\\", of: str\",\n \"100 * sauv[\\\"count\\\"] / self.parent.shape()[0] ) except: pass self.parent.__add_to_history__( \\\"[Discretize]:\",\n \"\\\"\\\"\\\" if isinstance(by, str): by = [by] if isinstance(order_by, str):\",\n \"result if elem[1] != None ] ), ) cmax =\",\n \"self.parent See Also -------- vDataFrame[].decode : Encodes the vColumn with\",\n \"Returns the k most occurent elements, how often they occur,\",\n \"\\\"NULL\\\", ) for elem in result if elem[2] != None\",\n \"outliers. mean : Replaces the upper and lower outliers by\",\n \"order_by] for elem in all_partition: if len(self.parent[elem].transformations) > max_floor: max_floor\",\n \"= (sauv[elem] - sauv[\\\"min\\\"]) / ( sauv[\\\"max\\\"] - sauv[\\\"min\\\"] )\",\n \"= ( '\\\"{}{}\\\"'.format(prefix, k) if (use_numbers_as_suffix) else '\\\"{}{}\\\"'.format( prefix, str(distinct_elements[k]).replace('\\\"',\",\n \"return_trans, [bool]), ] ) method = method.lower() self.parent.are_namecols_in(by) by =\",\n \"in [\\\"mode\\\", \\\"0ifnull\\\"]: max_floor = 0 all_partition = by if\",\n \") try: result = model.fit(self.parent.__genSQL__(), [self.alias]).plot( ax=ax, **style_kwds ) model.drop()\",\n \"and the MAX. MAX = MIN !\\\".format( self.alias ) warnings.warn(warning_message,\",\n \"elem in self.catalog: sauv[elem] = self.catalog[elem] self.parent.__update_catalog__(erase=True, columns=[self.alias]) try: if\",\n \"Density Plot. Parameters ---------- by: str, optional vColumn to use\",\n \"\\\"percent\\\" in elem: self.catalog[elem] = sauv[elem] elif elem == None:\",\n \"Returns the tail of the vColumn. \\\"\\\"\\\" check_types([(\\\"limit\\\", limit, [int,\",\n \"optional Interval width of the bar. If empty, an optimized\",\n \"(\\\"copy_name\\\", copy_name, [str])]) try: try: ctype = get_data_types( \\\"SELECT {}\",\n \"number of points to use to evaluate the approximate density\",\n \"if method in [\\\"ffill\\\", \\\"pad\\\", \\\"bfill\\\", \\\"backfill\\\"]: all_partition += [elem\",\n \"|______ / / / # |____/ / / # _____________\",\n \"---------- prefix: str, optional Prefix of the dummies. prefix_sep: str,\",\n \"pt_non_events, events / NULLIFZERO(SUM(events) OVER ()) AS pt_events FROM ({})\",\n \"response: str): \\\"\\\"\\\" --------------------------------------------------------------------------- Encodes the vColumn using the average\",\n \"\\\"\\\"\\\" return self.aggregate([\\\"max\\\"]).values[self.alias][0] # ---# def mean_encode(self, response: str): \\\"\\\"\\\"\",\n \"by[0], ), title=\\\"Computing the different categories to normalize.\\\", method=\\\"fetchall\\\", )\",\n \"**style_kwds, ): \\\"\\\"\\\" --------------------------------------------------------------------------- Draws the pie chart of the\",\n \": Keeps the topk most frequent categories and merge the\",\n \"= \\\"\\\"\\\"(SELECT {0} || '', COUNT(*) FROM vdf_table GROUP BY\",\n \"100 * (int(sauv[\\\"count\\\"]) + total) / self.parent.shape()[0] ) except: pass\",\n \"vColumn. Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].decode :\",\n \"Matplotlib axes object See Also -------- vDataFrame[].bar : Draws the\",\n \"alias. catalog, dict : Catalog of pre-computed aggregations. parent, vDataFrame\",\n \"values used to cut the vColumn. labels: list, optional Labels\",\n \"mean_alpha, mean_1_alpha = [ item[0] for item in executeSQL( query=query,\",\n \"stddev == 0: warning_message = \\\"Can not normalize {} using\",\n \"= \\\"\\\" if (k < 1) else \\\"LIMIT {}\\\".format(k) dropna\",\n \"1 ) result = executeSQL( query=query, title=\\\"Computing the optimized histogram\",\n \"the vDataFrame parent and do not apply it. This parameter\",\n \"vColumn {} was renamed '{}'.\\\".format(old_name, new_name) ) return parent #\",\n \": Returns True if the vColumn is boolean. vDataFrame[].isdate :\",\n \"aggregation. \\\"\\\"\\\" check_types( [ (\\\"by\\\", by, [str]), (\\\"method\\\", method, [str]),\",\n \"in the vDataFrame history. Returns ------- vDataFrame self.parent See Also\",\n \"= \\\"Others\\\", RFmodel_params: dict = {}, response: str = \\\"\\\",\",\n \"vDataFrame.aggregate : Computes the vDataFrame input aggregations. \\\"\\\"\\\" check_types([(\\\"approx\\\", approx,\",\n \"of the current axes. ax: Matplotlib axes object, optional The\",\n \"--------------------------------------------------------------------------- Verifies if the regular expression is in each of\",\n \"COUNT(*) DESC LIMIT {1})\\\"\\\"\\\".format( self.alias, max_cardinality ) if distinct_count >\",\n \"history. Returns ------- vDataFrame self.parent See Also -------- vDataFrame.drop: Drops\",\n \"( \\\"WHEN {} < {} THEN {} \\\".format(\\\"{}\\\", lower, lower)\",\n \"): query = \\\"\\\"\\\"(SELECT {0} || '', COUNT(*) FROM vdf_table\",\n \"xlim=xlim_tmp, store=False, ) try: result = model.fit(self.parent.__genSQL__(), [self.alias]).plot( ax=ax, **style_kwds\",\n \"vColumn using 'median'. Parameters ---------- approx: bool, optional If set\",\n \"Parameters ---------- new_name: str The new vColumn alias. Returns -------\",\n \"learning and scoring phases. xlim: tuple, optional Set the x\",\n \"str_extract(self, pat: str): \\\"\\\"\\\" --------------------------------------------------------------------------- Extracts the regular expression in\",\n \"the vColumn. Returns ------- list Distinct caterogies of the vColumn.\",\n \"self.transformations] total = self.count() if method not in [\\\"mode\\\", \\\"0ifnull\\\"]:\",\n \"limit, [int, float]), (\\\"offset\\\", offset, [int, float])]) if offset <\",\n \"self.alias, self.parent.__genSQL__(), self.parent.__get_last_order_by__(), index_start, limit, ) return vDataFrameSQL(query) elif isinstance(index,\",\n \"= self.min() xmax = self.max() else: xmin, xmax = xlim\",\n \"/ SECOND / TIME ZONE / TIMEZONE_HOUR / TIMEZONE_MINUTE /\",\n \"VERTICAPY_SUBTABLE) ORDER BY count DESC\\\" ).format(self.alias, max_cardinality + 1) query\",\n \"self.parent.__genSQL__(), by[0] ) result = executeSQL( query, title=\\\"Computing the different\",\n \"self.aggregate([\\\"sem\\\"]).values[self.alias][0] # ---# def skewness(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn\",\n \"= \\\"\\\", end_date: Union[str, datetime.datetime, datetime.date] = \\\"\\\", area: bool\",\n \"will be generated. include_lowest: bool, optional If set to True,\",\n \"Union # VerticaPy Modules import verticapy from verticapy.utilities import *\",\n \"import * from verticapy.errors import * ## # # __\",\n \"order_by, ParameterError( \\\"If the method is in ffill|pad|bfill|backfill then 'order_by'\",\n \"has been transformed multiple times, so it's better practice to\",\n \"input aggregations. \\\"\\\"\\\" return self.aggregate([\\\"skewness\\\"]).values[self.alias][0] skew = skewness # ---#\",\n \"to_replace.replace(\\\"'\\\", \\\"''\\\"), value.replace(\\\"'\\\", \\\"''\\\") ) ) # ---# def str_slice(self,\",\n \": Computes the vDataFrame input aggregations. \\\"\\\"\\\" check_types([(\\\"x\\\", x, [int,\",\n \"the different vColumn categories. Parameters ---------- response: str Response vColumn.\",\n \"= args[0] elif \\\"column\\\" in kwargs: column = kwargs[\\\"column\\\"] else:\",\n \"to compute the best splits when 'method' is set to\",\n \"Distinct caterogies of the vColumn. See Also -------- vDataFrame.topk :\",\n \"self.catalog[elem] = (sauv[elem] - sauv[\\\"approx_50%\\\"]) / ( 1.4826 * sauv[\\\"mad\\\"]\",\n \"= \\\"density\\\", of: str = \\\"\\\", max_cardinality: Union[int, tuple] =\",\n \"events FROM ({}) x GROUP BY 1\\\".format( self.alias, y, y,\",\n \"input aggregations. \\\"\\\"\\\" return self.aggregate([\\\"kurtosis\\\"]).values[self.alias][0] kurt = kurtosis # ---#\",\n \"\\\"{}\\\", length, unit.upper(), start_or_end ) ) # ---# def spider(\",\n \"--------------------------------------------------------------------------- Multiplies the vColumn by the input element. Parameters ----------\",\n \"can also be a cutomized aggregation (ex: AVG(column1) + 5).\",\n \"Warning) elif self.isnum(): if method == \\\"zscore\\\": if n ==\",\n \"return self.apply(func=\\\"SUBSTR({}, {}, {})\\\".format(\\\"{}\\\", start, step)) # ---# def sub(self,\",\n \"# Standard Python Modules import math, re, decimal, warnings, datetime\",\n \"method=\\\"fetchrow\\\", ) count, vColumn_min, vColumn_025, vColumn_075, vColumn_max = result sturges\",\n \"\\\"<=\\\", \\\"]\\\", \\\"]\\\" else: op1, op2, close_l, close_r = \\\"<=\\\",\",\n \"= ( 100 * sauv[\\\"count\\\"] / self.parent.shape()[0] ) for elem\",\n \"-------- vDataFrame.memory_usage : Returns the vDataFrame memory usage. \\\"\\\"\\\" import\",\n \"float, tuple] = (None, None), ax=None, **style_kwds, ): \\\"\\\"\\\" ---------------------------------------------------------------------------\",\n \"Encodes the vColumn with One-Hot Encoding. vDataFrame[].mean_encode : Encodes the\",\n \"Integer corresponding to the offset. For example, if n =\",\n \"[] model = KernelDensity( name, bandwidth=bandwidth, kernel=kernel, nbins=nbins, xlim=xlim_tmp, store=False,\",\n \"= [order_by] check_types( [ ( \\\"method\\\", method, [ \\\"auto\\\", \\\"mode\\\",\",\n \"The MAD is null !\\\".format( self.alias ) warnings.warn(warning_message, Warning) return\",\n \"the TS. start_date: str / date, optional Input Start Date.\",\n \"# / # VerticaPy is a Python library with scikit-like\",\n \"k) if (use_numbers_as_suffix) else '\\\"{}{}\\\"'.format( prefix, str(distinct_elements[k]).replace('\\\"', \\\"_\\\") ) )\",\n \"regular expression is in each of the vColumn records. vDataFrame[].str_count\",\n \"from the vColumn. Parameters ---------- x: float If the vColumn\",\n \"= 200, xlim: tuple = None, ax=None, **style_kwds, ): \\\"\\\"\\\"\",\n \"{}\\\".format(distinct_elements[k], k) expr = \\\", \\\".join(expr) + \\\", {})\\\".format(len(distinct_elements)) self.transformations\",\n \"method, [\\\"winsorize\\\", \\\"null\\\", \\\"mean\\\"]), (\\\"alpha\\\", alpha, [int, float]), (\\\"use_threshold\\\", use_threshold,\",\n \"0 avg, stddev = self.aggregate([\\\"avg\\\", \\\"std\\\"]).values[self.alias] if stddev == 0:\",\n \"scikit-like functionality for conducting # data science projects on data\",\n \"is only available for categorical variables.\\\" ) warnings.warn(warning_message, Warning) else:\",\n \"ctype = \\\"int\\\", \\\"bool\\\" else: category, ctype = self.category(), self.ctype()\",\n \"def nsmallest(self, n: int = 10): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns the\",\n \"(max - min) by: list, optional vColumns used in the\",\n \"'\\\"{}{}\\\"'.format(prefix, k) if (use_numbers_as_suffix) else '\\\"{}{}\\\"'.format( prefix, str(distinct_elements[k]).replace('\\\"', \\\"_\\\") )\",\n \"following list: [\\\"Fouad\\\", \\\"Badr\\\"] Returns ------- vDataFrame The vDataFrame of\",\n \"the next whole number cos : trigonometric cosine cosh :\",\n \"if method == \\\"zscore\\\": if n == 0: nullifzero =\",\n \"[int, float]), (\\\"nbins\\\", nbins, [int, float]), (\\\"h\\\", h, [int, float]),\",\n \"float])]) if n == 1: pre_comp = self.parent.__get_catalog_value__(self.alias, \\\"top\\\") if\",\n \"else: return self.apply(func=\\\"{} + ({})\\\".format(\\\"{}\\\", x)) # ---# def add_copy(self,\",\n \") # ---# def avg(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn\",\n \"self.alias, self.alias, self.parent.__genSQL__(), where, self.alias, n ), title=\\\"Computing the mode.\\\",\",\n \"must have a numerical value\\\" ) lower_when = ( \\\"WHEN\",\n \"---# def geo_plot(self, *args, **kwargs): \\\"\\\"\\\" --------------------------------------------------------------------------- Draws the Geospatial\",\n \"Focus or one of its affiliates. # Licensed under the\",\n \"implied. # See the License for the specific language governing\",\n \"{})\\\".format(field, \\\"{}\\\")) # ---# def decode(self, *argv): \\\"\\\"\\\" --------------------------------------------------------------------------- Encodes\",\n \"nbins used for the discretization (must be > 1) Returns\",\n \"return \\\"({} - {}) / {}({} - {})\\\".format( self.alias, cmin,\",\n \"version you are using. Returns ------- tablesample An object containing\",\n \"= \\\"\\\"): \\\"\\\"\\\" --------------------------------------------------------------------------- Applies a function to the vColumn.\",\n \"vColumn must be numerical for Normalization\\\") return self.parent # ---#\",\n \"else False if of: self.parent.are_namecols_in(of) of = self.parent.format_colnames(of) from verticapy.plot\",\n \"outliers using the input method. Parameters ---------- method: str, optional\",\n \"inverse tangent cbrt : cube root ceil : value up\",\n \"h: Union[int, float, tuple] = (None, None), ax=None, **style_kwds, ):\",\n \"THEN {} || '' ELSE '{}' END)\\\".format( bin_spatial_to_str(self.category()), \\\", \\\".join(\",\n \"\\\"({} BETWEEN {} AND {})\\\".format(self.alias, p_alpha, p_1_alpha) ) return self.parent\",\n \"- {}) / {}({} - {})\\\".format( \\\"{}\\\", cmin, \\\"NULLIFZERO\\\" if\",\n \"val = self.median() new_column = \\\"COALESCE({}, {})\\\".format(\\\"{}\\\", val) elif (len(by)\",\n \"ELSE argv[n] END Returns ------- vDataFrame self.parent See Also --------\",\n \"{} + {}{}) || ']'\\\".format( \\\"{}\\\", h, h, \\\"{}\\\", h,\",\n \"{}, } for elem in catalog: self.catalog[elem] = catalog[elem] #\",\n \"isbool(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns True if the vColumn is boolean,\",\n \"result = executeSQL( \\\"SELECT {} FROM (SELECT {}, COUNT(*) AS\",\n \"float]), (\\\"step\\\", step, [int, float])]) return self.apply(func=\\\"SUBSTR({}, {}, {})\\\".format(\\\"{}\\\", start,\",\n \"date, False otherwise. Returns ------- bool True if the vColumn\",\n \"\\\" \\\"the parameters ('prefix', 'prefix_sep'), you'll be able to solve\",\n \"0: offset = max(0, self.parent.shape()[0] - limit) title = \\\"Reads\",\n \"'approx_10%', APPROXIMATE_PERCENTILE ({3}{4} USING PARAMETERS percentile = 0.25) AS 'approx_25%',\",\n \"= new_name.replace('\\\"', \\\"\\\") assert not (self.parent.is_colname_in(new_name)), NameError( f\\\"A vColumn has\",\n \"in ([0, 1], [1, 0]) or self.isbool(): all_new_features = []\",\n \"max_cardinality: int = 6, h: float = 0, pie_type: str\",\n \"of {}.\\\".format(self.alias), method=\\\"fetchrow\\\", ) if method == \\\"winsorize\\\": self.clip(lower=p_alpha, upper=p_1_alpha)\",\n \"BY _verticapy_cnt_ ASC LIMIT 1\\\".format( self.alias, self.alias, self.parent.__genSQL__(), where, self.alias,\",\n \"> 0 else \\\"\\\", self.alias ), method=\\\"fetchall\\\", ) values =\",\n \"True): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using an input 'quantile'.\",\n \"isin(self, val: list, *args): \\\"\\\"\\\" --------------------------------------------------------------------------- Looks if some specific\",\n \"Standard Python Modules import math, re, decimal, warnings, datetime from\",\n \"self elif n == 1: try: result = executeSQL( \\\"SELECT\",\n \"a copy will be created using the input Name. Returns\",\n \"Draws the Box Plot of the input vColumns. \\\"\\\"\\\" if\",\n \"warning_message = \\\"Can not normalize {} using the MIN and\",\n \"), print_time_sql=False, ) except: new_column = \\\"COALESCE({}, {}({}) OVER (PARTITION\",\n \": Donut chart. rose : Rose chart. It can also\",\n \"usage. Returns ------- float vColumn memory usage (byte) See Also\",\n \"seconds, otherwise it will represent a number. Returns ------- vDataFrame\",\n \"isinstance(top, decimal.Decimal): top = float(top) self.parent.__update_catalog__( {\\\"index\\\": [\\\"top{}\\\".format(n)], self.alias: [top]}\",\n \"vColumn using the input method. Parameters ---------- method: str, optional\",\n \"copy vColumn to the parent vDataFrame. Parameters ---------- name: str\",\n \"Of Evidence (WOE) Table. It tells the predictive power of\",\n \"by: self.parent.are_namecols_in(by) by = self.parent.format_colnames(by) from verticapy.plot import ts_plot return\",\n \"float = 0, max_cardinality: int = 8, cat_priority: list =\",\n \"self.aggregate(func=[\\\"prod\\\"]).values[self.alias][0] prod = product # ---# def quantile(self, x: float,\",\n \"to convert the vColumn. If this parameter is equal to\",\n \"THEN {} ELSE NULL END)\\\".format( \\\"{}\\\", p_alpha, p_1_alpha, \\\"{}\\\" )\",\n \"def __len__(self): return int(self.count()) # ---# def __nonzero__(self): return self.count()\",\n \"max_cardinality=k) # ---# def var(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn\",\n \"AS (SELECT * FROM {}) {}\\\".format( self.parent.__genSQL__(), query ) query_result\",\n \"= \\\"\\\", max_cardinality: Union[int, tuple] = (6, 6), h: Union[int,\",\n \"will be filled. Returns ------- vDataFrame self.parent See Also --------\",\n \"val # # Methods # # ---# def aad(self): \\\"\\\"\\\"\",\n \"and include_lowest: op1, close_l = \\\"<=\\\", \\\"[\\\" elif idx ==\",\n \"0: warning_message = \\\"Can not normalize {} using a Z-Score\",\n \"= 0, h: float = 0, ax=None, **style_kwds, ): \\\"\\\"\\\"\",\n \"vColumn by transforming the values lesser than the lower bound\",\n \"vDataFrame input aggregations. \\\"\\\"\\\" return self.aggregate([\\\"count\\\"]).values[self.alias][0] # ---# def cut(\",\n \"'count' (Number of non-Missing elements). Returns ------- int number of\",\n \"the specific language governing permissions and # limitations under the\",\n \"the time series. \\\"\\\"\\\" check_types( [ (\\\"ts\\\", ts, [str]), (\\\"q\\\",\",\n \"vColumn alias. Returns ------- vDataFrame self.parent See Also -------- vDataFrame.add_copy\",\n \"the alias {new_name}.\\\\nBy changing the parameter 'new_name', you'll be able\",\n \"Matplotlib axes object See Also -------- vDataFrame.bar : Draws the\",\n \"optional The type of pie chart. auto : Regular pie\",\n \"catalog=self.catalog, ) setattr(self.parent, name, new_vColumn) setattr(self.parent, name[1:-1], new_vColumn) self.parent._VERTICAPY_VARIABLES_[\\\"columns\\\"] +=\",\n \"defined Encoding. vDataFrame[].get_dummies : Encodes the vColumn with One-Hot Encoding.\",\n \"self.parent See Also -------- vDataFrame[].date_part : Extracts a specific TS\",\n \"[ (\\\"alpha\\\", alpha, [int, float]), (\\\"use_threshold\\\", use_threshold, [bool]), (\\\"threshold\\\", threshold,\",\n \"labels[idx] else: label = f\\\"{close_l}{first_elem};{second_elem}{close_r}\\\" conditions += [ f\\\"'{first_elem}' {op1}\",\n \"to use to order the data\\\" ) desc = \\\"\\\"\",\n \"considered during the computation. n: int, optional Integer corresponding to\",\n \"train a Random Forest with 20 trees and a maximum\",\n \"------- float sem See Also -------- vDataFrame.aggregate : Computes the\",\n \"Slices and transforms the vColumn using a time series rule.\",\n \"from verticapy.learn.ensemble import ( RandomForestClassifier, RandomForestRegressor, ) drop(tmp_model_name, method=\\\"model\\\") if\",\n \"A copy of the vColumn {} named {} was added\",\n \"absolute deviation). Returns ------- float mad See Also -------- vDataFrame.aggregate\",\n \"input value. vDataFrame[].str_slice : Slices the vColumn. \\\"\\\"\\\" check_types([(\\\"pat\\\", pat,\",\n \"result except: model.drop() raise # ---# def describe( self, method:\",\n \"to_tablesample( \\\"SELECT {} AS {} FROM {}{} LIMIT {} OFFSET\",\n \"limit, ) return vDataFrameSQL(query) elif isinstance(index, int): cast = \\\"::float\\\"\",\n \"# ---# def sem(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using\",\n \"dropna: bool = True): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns the k most\",\n \"category, ctype = self.category(), self.ctype() copy_trans = [elem for elem\",\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\",\n \") assert len(breaks) == len(labels) + 1 or not (labels),\",\n \"bar. If empty, an optimized h will be computed. pie_type:\",\n \"int, optional The integer k of the 'topk' method. new_category:\",\n \"Information Value (IV) Table. \\\"\\\"\\\" check_types([(\\\"y\\\", y, [str]), (\\\"nbins\\\", nbins,\",\n \"[ \\\"'{}', {}\\\".format(str(distinct_elements[k]).replace(\\\"'\\\", \\\"''\\\"), k) ] text_info += \\\"\\\\t{} =>\",\n \"avg) / std robust_zscore : Normalization using the Robust Z-Score\",\n \"self.alias, ), \\\"apply_test_feature\\\", ) category = get_category_from_vertica_type(ctype=ctype) all_cols, max_floor =\",\n \": sum std : standard deviation topk : kth most\",\n \"{} < {}) UNION ALL (SELECT AVG({}) FROM vdf_table WHERE\",\n \"to skip. Returns ------- tablesample An object containing the result.\",\n \"float = 4.0, use_threshold: bool = True, alpha: float =\",\n \"the vDataFrame has been transformed multiple times, so it's better\",\n \"__ __ __ # /\\\\ \\\\ / / /\\\\ ___\\\\\",\n \"vColumn by dropping the current vColumn and creating a copy\",\n \"if (is_date) and not (method == \\\"categorical\\\"): result = self.aggregate([\\\"count\\\",\",\n \"to use to partition the data. method: str, optional The\",\n \"< 50): try: result = executeSQL( \\\"SELECT {}, AVG({}), STDDEV({})\",\n \"[sum(result[\\\"iv\\\"])] return result # ---# def kurtosis(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates\",\n \"for elem in result] except: drop(tmp_view_name, method=\\\"view\\\") drop(tmp_model_name, method=\\\"model\\\") raise\",\n \"elif self.isnum(): if method == \\\"zscore\\\": if n == 0:\",\n \"for the mode) topk_percent : kth most occurent element density\",\n \"count DESC\\\" ).format(self.alias, max_cardinality + 1) query = \\\"WITH vdf_table\",\n \"executeSQL( \\\"SELECT {} FROM (SELECT {}, COUNT(*) AS _verticapy_cnt_ FROM\",\n \"use_numbers_as_suffix, [bool]), ] ) distinct_elements = self.distinct() if distinct_elements not\",\n \"self.parent.__update_catalog__(erase=True, columns=[self.alias]) self.parent.__add_to_history__( \\\"[Apply]: The vColumn '{}' was transformed with\",\n \"\\\"\\\"\\\" return self.aggregate([\\\"kurtosis\\\"]).values[self.alias][0] kurt = kurtosis # ---# def label_encode(self):\",\n \"data when 'ts' is lesser than November 1993 the 3rd.\",\n \"self.aggregate([\\\"count\\\", \\\"min\\\", \\\"max\\\"]) index = result.values[\\\"index\\\"] result = result.values[self.alias] elif\",\n \"\\\"text\\\", ) elif self.isnum() and method == \\\"same_freq\\\": assert nbins\",\n \"If the vColumn type is date like (date, datetime ...),\",\n \"WHEN {} < {} THEN {} WHEN {} > {}\",\n \"query = [ \\\"(SELECT READ_TREE(USING PARAMETERS model_name = '{}', tree_id\",\n \"* from verticapy.toolbox import * from verticapy.errors import * ##\",\n \": Adds a new vColumn to the vDataFrame by using\",\n \"of, [str]), (\\\"max_cardinality\\\", max_cardinality, [int, float]), (\\\"nbins\\\", nbins, [int, float]),\",\n \"\\\"\\\"\\\" --------------------------------------------------------------------------- Returns the n largest vColumn elements. Parameters ----------\",\n \"[bool])]) topk = \\\"\\\" if (k < 1) else \\\"LIMIT\",\n \"be seen as one column of that relation. vColumns simplify\",\n \"(\\\"max_cardinality\\\", max_cardinality, [int, float]), (\\\"h\\\", h, [int, float]), (\\\"pie_type\\\", pie_type,\",\n \"= (0.25, 0.75), start_date: Union[str, datetime.datetime, datetime.date] = \\\"\\\", end_date:\",\n \"of matches for the regular expression in each record of\",\n \"= max(sturges, fd) self.parent.__update_catalog__({\\\"index\\\": [\\\"numh\\\"], self.alias: [best_h]}) if self.category() ==\",\n \"aggregations. \\\"\\\"\\\" return self.aggregate([\\\"mad\\\"]).values[self.alias][0] # ---# def max(self): \\\"\\\"\\\" ---------------------------------------------------------------------------\",\n \"has already the alias of one of the dummies ({name}).\\\\n\\\"\",\n \"3.0), 1e-99) if method.lower() == \\\"sturges\\\": best_h = sturges elif\",\n \"max and the min sem : standard error of the\",\n \"( \\\"{}::{}\\\".format(\\\"{}\\\", dtype), dtype, get_category_from_vertica_type(ctype=dtype), ) ] self.parent.__add_to_history__( \\\"[AsType]: The\",\n \"n)) # ---# def sem(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn\",\n \"self.parent except Exception as e: raise QueryError( \\\"{}\\\\nError when applying\",\n \"distinct elements to be used as categorical (No h will\",\n \"self.parent # ---# def count(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn\",\n \"using the input method. Parameters ---------- method: str, optional Method\",\n \"\\\"{}\\\", h, h, h, floor_end ), \\\"varchar\\\", \\\"text\\\", ) else:\",\n \"if not (h) or h <= 0: if nbins <=\",\n \"count(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using 'count' (Number of\",\n \"one parent. catalog: dict, optional Catalog where each key corresponds\",\n \"self.min() xmax = self.max() else: xmin, xmax = xlim custom_lines\",\n \"= [by] check_types( [ (\\\"method\\\", method, [\\\"zscore\\\", \\\"robust_zscore\\\", \\\"minmax\\\"]), (\\\"by\\\",\",\n \"APPROXIMATE_PERCENTILE ({3}{4} USING PARAMETERS percentile = 0.1) AS 'approx_10%', APPROXIMATE_PERCENTILE\",\n \": difference between the max and the min sem :\",\n \"AS _verticapy_cnt_, 100 * COUNT(*) / {} AS percent FROM\",\n \"'product'. Returns ------- float product See Also -------- vDataFrame.aggregate :\",\n \"\\\"count\\\"] + [item[0] for item in query_result] else: result =\",\n \"expr: str = \\\"\\\", by: list = [], order_by: list\",\n \"tail # ---# def isbool(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns True if\",\n \"{} FROM {} LIMIT 1\\\".format( cmax, cmin, self.parent.__genSQL__() ), print_time_sql=False,\",\n \"vDataFrame where the vColumn is missing. Returns ------- vDataFrame self.parent\",\n \"Also -------- vDataFrame.isin : Looks if some specific records are\",\n \"total = ( sys.getsizeof(self) + sys.getsizeof(self.alias) + sys.getsizeof(self.transformations) + sys.getsizeof(self.catalog)\",\n \"= ( self.alias.replace('\\\"', \\\"\\\") + prefix_sep.replace('\\\"', \\\"_\\\") if not (prefix)\",\n \"end_date, [str, datetime.datetime, datetime.date]), (\\\"area\\\", area, [bool]), (\\\"step\\\", step, [bool]),\",\n \"will be one of the following: date / int /\",\n \"(Minimum). Returns ------- float/str minimum See Also -------- vDataFrame.aggregate :\",\n \"---# def product(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using 'product'.\",\n \"Applies a function to the vColumn. Parameters ---------- func: str,\",\n \"Returns ------- vDataFrame self.parent See Also -------- vDataFrame.astype : Converts\",\n \": Catalog of pre-computed aggregations. parent, vDataFrame : Parent of\",\n \"\\\"\\\"\\\" check_types( [(\\\"method\\\", method, [\\\"sturges\\\", \\\"freedman_diaconis\\\", \\\"fd\\\", \\\"auto\\\"])] ) method\",\n \"same number of elements. same_width : Computes regular width bins.\",\n \"!= None ] ), ) cmax = \\\"DECODE({}, {}, NULL)\\\".format(\",\n \"numerical : Uses popular numerical aggregations during the computation. max_cardinality:\",\n \"y, y, query, ) query = \\\"SELECT {}, ord, non_events,\",\n \"optimal h. auto : Combination of Freedman Diaconis and Sturges.\",\n \"Encodes the vColumn using a user-defined encoding. vDataFrame[].discretize : Discretizes\",\n \"multiple children vColumns whereas one vColumn can only have one\",\n \"alpha: float = 0.05, ): \\\"\\\"\\\" --------------------------------------------------------------------------- Fills the vColumns\",\n \"distinct) var : variance Other aggregations could work if it\",\n \"\\\\ \\\\/\\\\ \\\\ \\\\ \\\\ \\\\____ \\\\ \\\\ \\\\_\\\\ \\\\\",\n \"parent vDataFrame. This parameter is used for testing purpose. Returns\",\n \"= \\\"int\\\", \\\"bool\\\" else: category, ctype = self.category(), self.ctype() copy_trans\",\n \"}, ) setattr(self.parent, name, new_vColumn) setattr(self.parent, name.replace('\\\"', \\\"\\\"), new_vColumn) self.parent._VERTICAPY_VARIABLES_[\\\"columns\\\"]\",\n \"if isinstance(index, slice): assert index.step in (1, None), ValueError( \\\"vColumn\",\n \"a Random Forest with 20 trees and a maximum depth\",\n \"== \\\"rose\\\" else False if of: self.parent.are_namecols_in(of) of = self.parent.format_colnames(of)\",\n \"[bool])]) if approx: return self.aggregate(func=[\\\"approx_unique\\\"]).values[self.alias][0] else: return self.aggregate(func=[\\\"unique\\\"]).values[self.alias][0] # ---#\",\n \"slicing. Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].str_contains :\",\n \"-------- vDataFrame[].nlargest : Returns the n largest vColumn elements. \\\"\\\"\\\"\",\n \"response: str, optional Response vColumn when method is set to\",\n \": approximative cardinality count : number of non-missing elements cvar\",\n \"for idx, elem in enumerate(result): result[idx][0] = ( \\\"NULL\\\" if\",\n \"\\\", \\\".join(by) ) elif method in (\\\"ffill\\\", \\\"pad\\\", \\\"bfill\\\", \\\"backfill\\\"):\",\n \"approximate median is returned. By setting this parameter to False,\",\n \"vColumn. vDataFrame.outliers : Adds a new vColumn labeled with 0\",\n \"in each of the vColumn records. vDataFrame[].extract : Extracts the\",\n \"to compute the optimal h. auto : Combination of Freedman\",\n \"pie( self, method, of, max_cardinality, h, donut, rose, ax=None, **style_kwds,\",\n \"self.__dict__[attr] = val # # Methods # # ---# def\",\n \"catalog: dict = {} ): self.parent, self.alias, self.transformations = (\",\n \"float): \\\"\\\"\\\" --------------------------------------------------------------------------- Divides the vColumn by the input element.\",\n \"value of the record is greater than the threshold it\",\n \"raise # ---# def describe( self, method: str = \\\"auto\\\",\",\n \"( \\\"method\\\", method, [\\\"auto\\\", \\\"smart\\\", \\\"same_width\\\", \\\"same_freq\\\", \\\"topk\\\"], ), (\\\"return_enum_trans\\\",\",\n \"/ # ____________ ______ # / __ `\\\\ / /\",\n \"# VerticaPy aims to do all of the above. The\",\n \"can have multiple children vColumns whereas one vColumn can only\",\n \"self.parent[response].category() == \\\"float\\\": model = RandomForestRegressor(tmp_model_name) else: model = RandomForestClassifier(tmp_model_name)\",\n \"color=updated_dict(param, style_kwds, idx)[\\\"color\\\"], lw=4, ), ] ax.set_title(\\\"KernelDensity\\\") ax.legend( custom_lines, columns,\",\n \"index.step in (1, None), ValueError( \\\"vColumn doesn't allow slicing having\",\n \"True, the approximate cardinality is returned. By setting this parameter\",\n \"vColumns. Parameters ---------- add_history: bool, optional If set to True,\",\n \"def __setattr__(self, attr, val): self.__dict__[attr] = val # # Methods\",\n \"Union[str, datetime.datetime, datetime.date] = \\\"\\\", area: bool = False, step:\",\n \"float, optional Uses the Gaussian distribution to identify outliers. After\",\n \"result.values[\\\"index\\\"] result = result.values[self.alias] elif (method == \\\"cat_stats\\\") and (numcol\",\n \"Response Column.\\\".format( self.alias, response ) ) if verticapy.options[\\\"print_info\\\"]: print(\\\"The mean\",\n \"-------- vDataFrame.drop: Drops the input vColumns from the vDataFrame. \\\"\\\"\\\"\",\n \"optional If set to True, the lowest element of the\",\n \"query = \\\"SELECT {}, ord, non_events, events, non_events / NULLIFZERO(SUM(non_events)\",\n \"[sum(result[\\\"events\\\"])] result.values[\\\"pt_non_events\\\"] += [\\\"\\\"] result.values[\\\"pt_events\\\"] += [\\\"\\\"] result.values[\\\"woe\\\"] += [\\\"\\\"]\",\n \"None if not (result) else result[0][0] if not (dropna): n\",\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 \"Filters the data using the input expression. \\\"\\\"\\\" self.parent.filter(\\\"{} IS\",\n \"warning_message = \\\"Can not normalize {} using a Robust Z-Score\",\n \"True, the intervals will be closed on the right. Returns\",\n \"> 1 else \\\" was \\\" self.parent.__add_to_history__( \\\"[Get Dummies]: One\",\n \"a function to the input vColumn. \\\"\\\"\\\" check_types( [ (\\\"breaks\\\",\",\n \"vDataFrame[].isbool : Returns True if the vColumn is boolean. vDataFrame[].isdate\",\n \"if fun == \\\"AVG\\\": val = self.avg() elif fun ==\",\n \"\\\\ \\\\_\\\\ \\\\ \\\\_\\\\ \\\\ \\\\_\\\\\\\\\\\"\\\\_\\\\ # \\\\/_/ \\\\/_____/ \\\\/_____/\",\n \"- {}) WITHIN GROUP (ORDER BY {}) OVER () FROM\",\n \"query, title=\\\"Computing the different aggregations.\\\", method=\\\"fetchall\\\", ) for idx, elem\",\n \") if return_trans: return \\\"({} - {}) / {}({} -\",\n \"aggregate(self, func: list): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using the\",\n \"parameter 'labels' + 1 or parameter 'labels' must be empty.\\\"\",\n \"the vColumn. vDataFrame[].get_dummies : Encodes the vColumn with One-Hot Encoding.\",\n \") upper_when = ( \\\"WHEN {} > {} THEN {}\",\n \"tuple, optional Set the x limits of the current axes.\",\n \"to impute the vColumn. method: dict, optional Method to use\",\n \"transformed using a mean encoding with {} as Response Column.\\\".format(\",\n \"\\\"cosh\\\", \\\"cot\\\", \\\"exp\\\", \\\"floor\\\", \\\"ln\\\", \\\"log\\\", \\\"log10\\\", \\\"mod\\\", \\\"pow\\\", \\\"round\\\",\",\n \"to partition the data. bandwidth: float, optional The bandwidth of\",\n \"renamed '{}'.\\\".format(old_name, new_name) ) return parent # ---# def round(self,\",\n \"if len(self.parent[elem].transformations) > max_floor: max_floor = len(self.parent[elem].transformations) max_floor -= len(self.transformations)\",\n \"used to draw the Plot. start_date: str / date, optional\",\n \"Returns ------- str/float/int vColumn nth most occurent element. See Also\",\n \"int = -1, k: int = 6, new_category: str =\",\n \"check_types([(\\\"add_history\\\", add_history, [bool])]) try: parent = self.parent force_columns = [\",\n \"\\\", \\\".join( [ \\\"{}, {}\\\".format( \\\"'{}'\\\".format(str(elem[0]).replace(\\\"'\\\", \\\"''\\\")) if elem[0] !=\",\n \"sys.getsizeof(self) + sys.getsizeof(self.alias) + sys.getsizeof(self.transformations) + sys.getsizeof(self.catalog) ) for elem\",\n \"bools), a RF Classifier otherwise. Example: Write {\\\"n_estimators\\\": 20, \\\"max_depth\\\":\",\n \"# ---# def round(self, n: int): \\\"\\\"\\\" --------------------------------------------------------------------------- Rounds the\",\n \"by keeping only the input number of digits after the\",\n \"Matplotlib functions. Returns ------- ax Matplotlib axes object See Also\",\n \"NOT NULL GROUP BY 1) x ORDER BY verticapy_agg DESC\\\".format(\",\n \"[by] if isinstance(order_by, str): order_by = [order_by] check_types( [ (\",\n \"distinct categories of the vColumn. Returns ------- list Distinct caterogies\",\n \"( \\\"NULL\\\" if (elem[0] == None) else \\\"'{}'\\\".format(str(elem[0]).replace(\\\"'\\\", \\\"''\\\")) )\",\n \"will be computed. nbins: int, optional Number of bins used\",\n \"an input value. The vColumn will be transformed. Parameters ----------\",\n \"\\\"Can not normalize {} using a Robust Z-Score - The\",\n \"\\\"[Mean Encode]: The vColumn {} was transformed using a mean\",\n \"\\\" + \\\" WHEN \\\".join(conditions) + \\\" END\\\" self.apply(func=expr) #\",\n \"the data when 'ts' is lesser than November 1993 the\",\n \"must be greater or equal to 2.\\\" ) assert len(breaks)\",\n \"self, ts: str, q: tuple = (0.25, 0.75), start_date: Union[str,\",\n \"\\\"regr_sxx\\\": {}, \\\"regr_sxy\\\": {}, \\\"regr_syy\\\": {}, } for elem in\",\n \"if (by) else \\\"\\\" ) order_by_ts = \\\", \\\".join([quote_ident(column) +\",\n \"'ts' is lesser than November 1993 the 3rd. end_date: str\",\n \"record of the vColumn. The vColumn will be transformed. Parameters\",\n \"in case of discretization using the method 'smart'.\\\" ) self.parent.are_namecols_in(response)\",\n \"\\\"\\\"\\\" return self.quantile(0.5, approx=approx) # ---# def memory_usage(self): \\\"\\\"\\\" ---------------------------------------------------------------------------\",\n \"(\\\"by\\\", by, [str]), (\\\"kernel\\\", kernel, [\\\"gaussian\\\", \\\"logistic\\\", \\\"sigmoid\\\", \\\"silverman\\\"]), (\\\"bandwidth\\\",\",\n \"FROM ({}) x GROUP BY 1\\\".format( self.alias, y, y, query,\",\n \"float, optional The interval size to convert to use to\",\n \"bound. Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].fill_outliers :\",\n \"the vColumn using 'avg' (Average). Returns ------- float average See\",\n \"Series of the vColumn. Parameters ---------- ts: str TS (Time\",\n \"For example, to check if Badr and Fouad are in\",\n \"vColumn is numerical , 'categorical' otherwise. categorical : Uses only\",\n \"split_value, MAX(weighted_information_gain) FROM ({}) VERTICAPY_SUBTABLE WHERE split_value IS NOT NULL\",\n \"BY {}\\\".format( bin_spatial_to_str(self.category(), self.alias), self.alias, self.parent.__genSQL__(), self.alias, self.alias, self.alias, )\",\n \"4.0, use_threshold: bool = True, alpha: float = 0.05, ):\",\n \") title = \\\"Reads {} {} smallest elements.\\\".format(n, self.alias) return\",\n \"\\\"\\\"\\\" check_types( [ ( \\\"func\\\", func, [ \\\"abs\\\", \\\"acos\\\", \\\"asin\\\",\",\n \"str, optional Method to use to normalize. zscore : Normalization\",\n \"count : number of non-missing elements cvar : conditional value\",\n \"approx else \\\"\\\" return self.aggregate(func=[prefix + \\\"{}%\\\".format(x * 100)]).values[self.alias][ 0\",\n \"'{}' was transformed with the func 'x -> {}'.\\\".format( copy_name.replace('\\\"',\",\n \"vDataFrame input aggregations. \\\"\\\"\\\" return self.aggregate([\\\"min\\\"]).values[self.alias][0] # ---# def mode(self,\",\n \"Computes the vDataFrame input aggregations. \\\"\\\"\\\" return self.aggregate(func=[\\\"prod\\\"]).values[self.alias][0] prod =\",\n \"AVG({3}{4}) AS mean, STDDEV({3}{4}) AS std, MIN({3}{4}) AS min, APPROXIMATE_PERCENTILE\",\n \"category)] self.parent.__update_catalog__(erase=True, columns=[self.alias]) self.parent.__add_to_history__( \\\"[Apply]: The vColumn '{}' was transformed\",\n \"0 and include_lowest: op1, close_l = \\\"<=\\\", \\\"[\\\" elif idx\",\n \") if func not in (\\\"log\\\", \\\"mod\\\", \\\"pow\\\", \\\"round\\\"): expr\",\n \"# ---# def quantile(self, x: float, approx: bool = True):\",\n \": hyperbolic cosine cot : trigonometric cotangent exp : exponential\",\n \"using a time series rule. \\\"\\\"\\\" return self.apply(func=\\\"DATE_PART('{}', {})\\\".format(field, \\\"{}\\\"))\",\n \"column for column in self.parent._VERTICAPY_VARIABLES_[\\\"columns\\\"] ] force_columns.remove(self.alias) executeSQL( \\\"SELECT *\",\n \"input aggregations. \\\"\\\"\\\" check_types([(\\\"dropna\\\", dropna, [bool]), (\\\"n\\\", n, [int, float])])\",\n \"Returns the vColumn DB type. Returns ------- str vColumn DB\",\n \"OVER (PARTITION BY {})\\\".format( self.alias, \\\", \\\".join(by) ), \\\"STDDEV({}) OVER\",\n \"AS NAs, MIN({}) AS min, APPROXIMATE_PERCENTILE({} USING PARAMETERS percentile =\",\n \"self.parent.to_db(tmp_view_name) from verticapy.learn.ensemble import ( RandomForestClassifier, RandomForestRegressor, ) drop(tmp_model_name, method=\\\"model\\\")\",\n \"name=\\\"view\\\") tmp_model_name = gen_tmp_name(schema=schema, name=\\\"model\\\") assert nbins >= 2, ParameterError(\",\n \"\\\"_\\\") ) expr = \\\"DECODE({}, '{}', 1, 0)\\\".format( \\\"{}\\\", str(distinct_elements[k]).replace(\\\"'\\\",\",\n \"ax=None, **style_kwds, ): \\\"\\\"\\\" --------------------------------------------------------------------------- Draws the histogram of the\",\n \"[item[0] for item in query_result] else: result = ( self.parent.describe(\",\n \": Computes the vDataFrame input aggregations. \\\"\\\"\\\" return self.aggregate([\\\"stddev\\\"]).values[self.alias][0] stddev\",\n \"= [ item[0] for item in executeSQL( query=query, title=\\\"Computing the\",\n \") ) assert not (self.parent.is_colname_in(name)), NameError( f\\\"A vColumn has already\",\n \"drop_outliers( self, threshold: float = 4.0, use_threshold: bool = True,\",\n \"COUNT(*) AS _verticapy_cnt_ FROM {}{}GROUP BY {} ORDER BY _verticapy_cnt_\",\n \"transformations: list, optional List of the different transformations. Each transformation\",\n \"0 for elem in by: if len(self.parent[elem].transformations) > max_floor: max_floor\",\n \"encoding of a response. \\\"\\\"\\\" check_types( [ (\\\"RFmodel_params\\\", RFmodel_params, [dict]),\",\n \"the vColumn using a user-defined encoding. vDataFrame[].discretize : Discretizes the\",\n \"name, parent=self.parent, transformations=transformations, catalog={ \\\"min\\\": 0, \\\"max\\\": 1, \\\"count\\\": self.parent.shape()[0],\",\n \"Encodes the vColumn with One-Hot Encoding. \\\"\\\"\\\" check_types([(\\\"response\\\", response, [str])])\",\n \"{}, {} AS ord, {}::int AS {} FROM {}\\\".format( trans,\",\n \"---------- method: str, optional The method to use to discretize\",\n \"nb = int(float(count / int(nbins))) assert nb != 0, Exception(\",\n \"else: raise TypeError(\\\"The vColumn must be numerical for Normalization\\\") return\",\n \"else: p_alpha, p_1_alpha = ( self.parent.quantile([alpha, 1 - alpha], [self.alias])\",\n \"= self.parent.format_colnames(of) from verticapy.plot import spider as spider_plot return spider_plot(\",\n \"for i in range(len(result)): if result[i][2] == None: pass elif\",\n \"vColumn. Parameters ---------- n: int, optional Offset. Returns ------- tablesample\",\n \"or computed) ax: Matplotlib axes object, optional The axes to\",\n \"tmp_query + rp] query = \\\"WITH vdf_table AS (SELECT *\",\n \"fun, self.alias, self.parent.__genSQL__(), by[0] ) result = executeSQL( query, title=\\\"Computing\",\n \"float between 0 and 1 that represents the quantile. For\",\n \"vdf_table WHERE {} < {}) UNION ALL (SELECT AVG({}) FROM\",\n \"distinct elements to be used as categorical. The less frequent\",\n \"{} ORDER BY {}\\\".format( bin_spatial_to_str(self.category(), self.alias), self.alias, self.parent.__genSQL__(), self.alias, self.alias,\",\n \"this case, the parameter 'numcol' must be defined. numerical :\",\n \"keeping only the input number of digits after the comma.\",\n \": Encodes the vColumn with a user defined Encoding. vDataFrame[].discretize\",\n \"vColumn using a time series rule. Parameters ---------- length: int\",\n \"{}, \\\"regr_sxy\\\": {}, \\\"regr_syy\\\": {}, } for elem in catalog:\",\n \"NULL ORDER BY {} DESC LIMIT {}\\\".format( self.parent.__genSQL__(), self.alias, self.alias,\",\n \"dropna, [bool])]) topk = \\\"\\\" if (k < 1) else\",\n \"-------- vDataFrame[].date_part : Extracts a specific TS field from the\",\n \"See Also -------- vDataFrame.memory_usage : Returns the vDataFrame memory usage.\",\n \"/ {} AS percent FROM {}{} GROUP BY {} ORDER\",\n \"\\\".join(by) ), \\\"MIN({}) OVER (PARTITION BY {})\\\".format( self.alias, \\\", \\\".join(by)\",\n \"--------------------------------------------------------------------------- Aggregates the vColumn using 'skewness'. Returns ------- float skewness\",\n \"upper outliers.\\\".format( self.alias ), method=\\\"fetchall\\\", ) ] if mean_alpha ==\",\n \"('prefix', 'prefix_sep'), you'll be able to solve this \\\" \\\"issue.\\\"\",\n \"database type. \\\"\\\"\\\" return self.transformations[-1][2] # ---# def clip(self, lower=None,\",\n \"argv[n] END Returns ------- vDataFrame self.parent See Also -------- vDataFrame.case_when\",\n \"in case of discretization using the method 'smart'.\\\" ) assert\",\n \"op2, close_l, close_r = \\\"<\\\", \\\"<=\\\", \\\"]\\\", \\\"]\\\" else: op1,\",\n \"raise QueryError(\\\"{}\\\\nAn Error happened during the filling.\\\".format(e)) if total >\",\n \"histogram of the vColumn based on an aggregation. \\\"\\\"\\\" check_types(\",\n \"used to transform the vColumn. The function variable must be\",\n \"Encodes the vColumn with the One-Hot Encoding algorithm. Parameters ----------\",\n \"== \\\"auto\\\": pre_comp = self.parent.__get_catalog_value__(self.alias, \\\"numh\\\") if pre_comp != \\\"VERTICAPY_NOT_PRECOMPUTED\\\":\",\n \"Also -------- vDataFrame.plot : Draws the time series. \\\"\\\"\\\" check_types(\",\n \"-({}), {})\\\".format(x, \\\"{}\\\")) else: return self.apply(func=\\\"{} - ({})\\\".format(\\\"{}\\\", x)) #\",\n \"+= sys.getsizeof(elem) return total # ---# def min(self): \\\"\\\"\\\" ---------------------------------------------------------------------------\",\n \"Also -------- vDataFrame.apply : Applies functions to the input vColumns.\",\n \"except: self.parent._VERTICAPY_VARIABLES_[\\\"exclude_columns\\\"] += [self.alias] if add_history: self.parent.__add_to_history__( \\\"[Drop]: vColumn {}\",\n \"bool = True): \\\"\\\"\\\" --------------------------------------------------------------------------- Drops the vColumn from the\",\n \"vColumn using a bijection from the different categories to [0,\",\n \"str, optional vColumn to use to partition the data. bandwidth:\",\n \"must be defined. numerical : Uses popular numerical aggregations during\",\n \"self.alias ) warnings.warn(warning_message, Warning) return self elif n == 1:\",\n \"func.replace(\\\"{}\\\", \\\"x\\\"), ) ) else: for k in range(max_floor): self.transformations\",\n \"the vColumn using 'sum'. Returns ------- float sum See Also\",\n \"multiple times, so it's better practice to use this method\",\n \"int))) else \\\"\\\" ) upper_when = ( \\\"WHEN {} >\",\n \"Computes the number of matches for the regular expression in\",\n \"\\\"Can not normalize {} using a Z-Score - The Standard\",\n \"instead of the vDataFrame parent and do not apply it.\",\n \"is only available on type numeric|date\\\" ) if self.isnum(): result\",\n \"\\\"({} - {}) / ({})\\\".format(self.alias, med, mad) else: final_transformation =\",\n \"auto : Sets the method to 'numerical' if the vColumn\",\n \"Applies a default function to the vColumn. Parameters ---------- func:\",\n \"/ DECADE / DOQ / DOW / DOY / EPOCH\",\n \"[\\\"date\\\", \\\"float\\\"]: warning_message = ( \\\"label_encode is only available for\",\n \"to use to normalize. zscore : Normalization using the Z-Score\",\n \"encoder was applied to the vColumn {}\\\\n{} feature{}created: {}\\\".format( self.alias,\",\n \"Exception( \\\"Not enough values to compute the Equal Frequency discretization\\\"\",\n \"Draws the Bar Chart of vColumn based on an aggregation.\",\n \"executeSQL(query, title=\\\"Testing the Type casting.\\\") self.transformations += [ ( \\\"{}::{}\\\".format(\\\"{}\\\",\",\n \"order_by = [order_by] check_types( [ ( \\\"method\\\", method, [ \\\"auto\\\",\",\n \"range(parameters[\\\"n_estimators\\\"]) ] query = \\\"SELECT split_value FROM (SELECT split_value, MAX(weighted_information_gain)\",\n \"BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either\",\n \"inverse sine atan : trigonometric inverse tangent cbrt : cube\",\n \"else \\\"AVG\\\" if by == []: if fun == \\\"AVG\\\":\",\n \"self.category())] self.transformations += [(func, ctype, category)] self.parent.__update_catalog__(erase=True, columns=[self.alias]) self.parent.__add_to_history__( \\\"[Apply]:\",\n \"float]), (\\\"unit\\\", unit, [str]), (\\\"start\\\", start, [bool]), ] ) start_or_end\",\n \"hyperbolic sine sqrt : arithmetic square root tan : trigonometric\",\n \"instead of the parent vDataFrame. This parameter is used for\",\n \"True if the vColumn is numerical. \\\"\\\"\\\" return self.category() ==\",\n \"vDataFrame.outliers : Adds a new vColumn labeled with 0 and\",\n \"using the method 'smart'.\\\" ) assert response, ParameterError( \\\"Parameter 'response'\",\n \"right: bool = True, ): \\\"\\\"\\\" --------------------------------------------------------------------------- Discretizes the vColumn\",\n \"of bins used for the discretization (must be > 1)\",\n \"the response is numerical (except ints and bools), a RF\",\n \"right: op1, op2, close_l, close_r = \\\"<\\\", \\\"<=\\\", \\\"]\\\", \\\"]\\\"\",\n \"this parameter to False, the function's performance can drastically decrease.\",\n \"{}.\\\".format( numcol, self.alias ) values = to_tablesample(query, title=title).values elif (\",\n \"float sum See Also -------- vDataFrame.aggregate : Computes the vDataFrame\",\n \"Z-Score - The MAD is null !\\\".format( self.alias ) warnings.warn(warning_message,\",\n \"tmp_query = \\\"\\\"\\\"SELECT '{0}' AS 'index', COUNT({1}) AS count, 100\",\n \"int): if index_stop < 0: index_stop += self.parent.shape()[0] limit =\",\n \"Number of elements. density : Percentage of the distribution. mean\",\n \": Returns the a part of the vColumn. \\\"\\\"\\\" return\",\n \"!= \\\"cat_stats\\\": values = { \\\"index\\\": [\\\"name\\\", \\\"dtype\\\"] + index,\",\n \"write the following list: [\\\"Fouad\\\", \\\"Badr\\\"] Returns ------- vDataFrame The\",\n \"elem[2] != None ] ), ) executeSQL( \\\"SELECT {}, {}\",\n \"trans, self.alias, self.alias, y, y, self.parent.__genSQL__(), ) query = \\\"SELECT\",\n \"Diaconis [2 * IQR / n ** (1 / 3)]\",\n \"EPOCH / HOUR / ISODOW / ISOWEEK / ISOYEAR /\",\n \"\\\"{}\\\" ) ) elif method == \\\"mean\\\": query = \\\"WITH\",\n \"def _repr_html_(self): return self.head(limit=verticapy.options[\\\"max_rows\\\"])._repr_html_() # ---# def __setattr__(self, attr, val):\",\n \"columns = [self.alias] if of: self.parent.are_namecols_in(of) of = self.parent.format_colnames(of) from\",\n \"k: int = -1, dropna: bool = True): \\\"\\\"\\\" ---------------------------------------------------------------------------\",\n \"get_dummies( self, prefix: str = \\\"\\\", prefix_sep: str = \\\"_\\\",\",\n \"aggregations. parent, vDataFrame : Parent of the vColumn. transformations, str\",\n \"max_cardinality, nbins, h, ax=ax, **style_kwds) # ---# def boxplot( self,\",\n \"* FROM {}) {}\\\".format( self.parent.__genSQL__(), \\\" UNION ALL \\\".join(query) )\",\n \"fillna( self, val=None, method: str = \\\"auto\\\", expr: str =\",\n \"be computed if the parameter is empty or invalid. max_cardinality:\",\n \"to_replace, [str]), (\\\"value\\\", value, [str])]) return self.apply( func=\\\"REGEXP_REPLACE({}, '{}', '{}')\\\".format(\",\n \") new_vColumn = vColumn( name, parent=self.parent, transformations=[item for item in\",\n \"data around for processing, VerticaPy brings the logic to the\",\n \"[str])]) return self.apply( func=\\\"REGEXP_COUNT({}, '{}')\\\".format(\\\"{}\\\", pat.replace(\\\"'\\\", \\\"''\\\")) ) # ---#\",\n \"+= [(func, ctype, category)] self.parent.__update_catalog__(erase=True, columns=[self.alias]) self.parent.__add_to_history__( \\\"[Apply]: The vColumn\",\n \"isinstance(xlim, (tuple, list)): xlim_tmp = [xlim] else: xlim_tmp = []\",\n \"= self.parent.format_colnames(by) from verticapy.plot import ts_plot return ts_plot( self, ts,\",\n \"the vColumn using 'mad' (median absolute deviation). Returns ------- float\",\n \"parent # ---# def drop_outliers( self, threshold: float = 4.0,\",\n \"width of the vColumns 1 and 2 bars. It is\",\n \"See Also -------- vDataFrame.fill_outliers : Fills the outliers in the\",\n \"check_types( [ (\\\"RFmodel_params\\\", RFmodel_params, [dict]), (\\\"return_enum_trans\\\", return_enum_trans, [bool]), (\\\"h\\\", h,\",\n \"transformations, str : List of the different transformations. \\\"\\\"\\\" #\",\n \"/ # \\\\ / / / # \\\\/ / /\",\n \"] self.parent[copy_name].transformations += [(func, ctype, category)] self.parent[copy_name].catalog = self.catalog self.parent.__add_to_history__(\",\n \"self.iloc(limit=limit, offset=-1) # ---# def topk(self, k: int = -1,\",\n \"will be computed. ax: Matplotlib axes object, optional The axes\",\n \"---# def add(self, x: float): \\\"\\\"\\\" --------------------------------------------------------------------------- Adds the input\",\n \"numerical / date-like vColumns.\\\" ) assert len(breaks) >= 2, ParameterError(\",\n \"represent the number of seconds, otherwise it will represent a\",\n \"vColumn using the input list. Parameters ---------- breaks: list List\",\n \"approx: bool = True, ): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn\",\n \"** (1.0 / 3.0), 1e-99) if method.lower() == \\\"sturges\\\": best_h\",\n \"normalize( self, method: str = \\\"zscore\\\", by: list = [],\",\n \") else: cmax, cmin = ( \\\"MAX({}) OVER (PARTITION BY\",\n \"------- vDataFrame self.parent See Also -------- vDataFrame[].str_contains : Verifies if\",\n \"name, new_vColumn) setattr(self.parent, name.replace('\\\"', \\\"\\\"), new_vColumn) self.parent._VERTICAPY_VARIABLES_[\\\"columns\\\"] += [name] all_new_features\",\n \"warnings.warn(warning_message, Warning) elif self.isnum(): if method == \\\"zscore\\\": if n\",\n \"FLOOR({} / {}) * {} || ';' || (FLOOR({} /\",\n \"The Standard Deviation is null !\\\".format( self.alias ) warnings.warn(warning_message, Warning)\",\n \"parent # ---# def round(self, n: int): \\\"\\\"\\\" --------------------------------------------------------------------------- Rounds\",\n \"{} FROM {}{} OFFSET {}{}) VERTICAPY_SUBTABLE\\\".format( self.alias, self.parent.__genSQL__(), self.parent.__get_last_order_by__(), index_start,\",\n \"the data using the input expression. \\\"\\\"\\\" self.parent.filter(\\\"{} IS NOT\",\n \"columns=[self.alias]) self.parent.__add_to_history__( \\\"[Mean Encode]: The vColumn {} was transformed using\",\n \"spider_plot( self.parent, columns, method, of, max_cardinality, h, ax=ax, **style_kwds, )\",\n \"be one of the following: CENTURY / DAY / DECADE\",\n \"self.parent.__genSQL__(), by[0], ), title=\\\"Computing the different categories to normalize.\\\", method=\\\"fetchall\\\",\",\n \"_ __|_. _ _ |_) # \\\\/ (/_| | |(_(_||\",\n \"DOQ / DOW / DOY / EPOCH / HOUR /\",\n \"str, optional The describe method. auto : Sets the method\",\n \"missing value{} filled.\\\".format( total, self.alias, conj, ) ) else: if\",\n \"self.parent See Also -------- vDataFrame.filter: Filters the data using the\",\n \"> 6) else \\\"mode\\\" total = self.count() if (method ==\",\n \"e, self.alias, dtype ) ) # ---# def avg(self): \\\"\\\"\\\"\",\n \"def boxplot( self, by: str = \\\"\\\", h: float =\",\n \"\\\"density\\\", of: str = \\\"\\\", max_cardinality: int = 6, h:\",\n \"i] THEN argv[2 * i + 1] ... END odd\",\n \"(\\\"ffill\\\", \\\"pad\\\", \\\"bfill\\\", \\\"backfill\\\"): assert order_by, ParameterError( \\\"If the method\",\n \"two input quantiles. Parameters ---------- ts: str TS (Time Series)\",\n \"evaluating some conditions. vDataFrame[].discretize : Discretizes the vColumn. vDataFrame[].label_encode :\",\n \"the vColumn cardinality). Returns ------- vDataFrame self.parent See Also --------\",\n \"(isinstance(upper, (float, int))) else \\\"\\\" ) func = \\\"(CASE {}{}ELSE\",\n \"occurent element density unique : cardinality (count distinct) var :\",\n \"alias of one of the dummies ({name}).\\\\n\\\" \\\"It can be\",\n \"Returns ------- ax Matplotlib axes object See Also -------- vDataFrame.donut\",\n \"will be transformed. Parameters ---------- pat: str Regular expression. Returns\",\n \"Aggregates the vColumn using 'var' (Variance). Returns ------- float var\",\n \"which that stores all user transformations. If the vDataFrame represents\",\n \": Silverman kernel. nbins: int, optional Maximum number of points\",\n \"True if the vColumn is numerical, False otherwise. Returns -------\",\n \": Applies a function to the input vColumn. \\\"\\\"\\\" check_types([(\\\"n\\\",\",\n \"AS min, APPROXIMATE_PERCENTILE ({3}{4} USING PARAMETERS percentile = 0.1) AS\",\n \"50): try: if fun == \\\"MEDIAN\\\": fun = \\\"APPROXIMATE_MEDIAN\\\" query\",\n \"): \\\"\\\"\\\" --------------------------------------------------------------------------- Normalizes the input vColumns using the input\",\n \"\\\"cov\\\": {}, \\\"pearson\\\": {}, \\\"spearman\\\": {}, \\\"spearmand\\\": {}, \\\"kendall\\\": {},\",\n \"in sauv: if \\\"top\\\" in elem: if \\\"percent\\\" in elem:\",\n \"‘pipeline’ mechanism to sequentialize # data transformation operations, and offers\",\n \"the License is distributed on an \\\"AS IS\\\" BASIS, #\",\n \"** (1 / 3)] sturges : Sturges [CEIL(log2(n)) + 1]\",\n \"{} FROM {}\\\".format( trans, self.alias, self.alias, y, y, self.parent.__genSQL__(), )\",\n \"Name. Returns ------- vDataFrame self.parent See Also -------- vDataFrame.apply :\",\n \"sauv[elem] = self.catalog[elem] self.parent.__update_catalog__(erase=True, columns=[self.alias]) try: if \\\"count\\\" in sauv:\",\n \"{} < {} THEN {} \\\".format(\\\"{}\\\", lower, lower) if (isinstance(lower,\",\n \"the approximate median is returned. By setting this parameter to\",\n \"vColumn has already the alias {name}.\\\\nBy changing the parameter 'name',\",\n \"function. Increasing this parameter will increase the precision but will\",\n \"the vColumn using a bijection from the different categories to\",\n \"vDataFrame[].str_slice : Slices the vColumn. \\\"\\\"\\\" check_types([(\\\"to_replace\\\", to_replace, [str]), (\\\"value\\\",\",\n \"the Gaussian distribution to identify outliers. After normalizing the data\",\n \"and a maximum depth of 10. response: str, optional Response\",\n \"as suffix instead of the vColumns categories. Returns ------- vDataFrame\",\n \"of ambiguous columns naming.\\\\nBy changing one of \\\" \\\"the parameters\",\n \"closed. If set to True, the intervals will be closed\",\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)\",\n \"the vColumn. \\\"\\\"\\\" check_types([(\\\"pat\\\", pat, [str])]) return self.apply( func=\\\"REGEXP_SUBSTR({}, '{}')\\\".format(\\\"{}\\\",\",\n \"performance can drastically decrease. Returns ------- int vColumn cardinality (or\",\n \"self.parent # ---# def mad(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn\",\n \"(\\\"max_cardinality\\\", max_cardinality, [list]), (\\\"h\\\", h, [list, float, int]), ] )\",\n \"= \\\"s were \\\" if len(all_new_features) > 1 else \\\"\",\n \"[str]), (\\\"copy_name\\\", copy_name, [str])]) try: try: ctype = get_data_types( \\\"SELECT\",\n \"{1})\\\"\\\"\\\".format( self.alias, max_cardinality ) if distinct_count > max_cardinality: query +=\",\n \"DOW / DOY / EPOCH / HOUR / ISODOW /\",\n \"(Constant Interpolation). mean : Average. median : median. mode :\",\n \"vColumn DB type. \\\"\\\"\\\" return self.transformations[-1][1].lower() dtype = ctype #\",\n \"else \\\"LIMIT {}\\\".format(k) dropna = \\\" WHERE {} IS NOT\",\n \"str = \\\"auto\\\", expr: str = \\\"\\\", by: list =\",\n \"the vColumns are numerical. Optimized h will be computed if\",\n \"area: bool, optional If set to True, draw an Area\",\n \"self.parent.format_colnames(ts) if by: self.parent.are_namecols_in(by) by = self.parent.format_colnames(by) from verticapy.plot import\",\n \"(count) ** (1.0 / 3.0), 1e-99) if method.lower() == \\\"sturges\\\":\",\n \"FROM {}\\\".format( trans, self.alias, self.alias, y, y, self.parent.__genSQL__(), ) query\",\n \"Computes the vDataFrame input aggregations. \\\"\\\"\\\" return self.aggregate([\\\"skewness\\\"]).values[self.alias][0] skew =\",\n \"\\\"\\\"\\\" --------------------------------------------------------------------------- Slices and transforms the vColumn using a time\",\n \"by: list = [], return_trans: bool = False ): \\\"\\\"\\\"\",\n \"\\\"\\\"\\\" check_types([(\\\"x\\\", x, [int, float])]) if self.isdate(): return self.apply(func=\\\"TIMESTAMPADD(SECOND, {},\",\n \"\\\"index\\\": [\\\"name\\\", \\\"dtype\\\"] + index, \\\"value\\\": [self.alias, self.ctype()] + result,\",\n \"Draws the histogram of the vColumn based on an aggregation.\",\n \"---------- length: int Slice size. unit: str, optional Slice size\",\n \"return self.apply(func=st.decode(str_sql(\\\"{}\\\"), *argv)) # ---# def density( self, by: str\",\n \"using the method 'topk'\\\" ) distinct = self.topk(k).values[\\\"index\\\"] trans =\",\n \"left\\\", bbox_to_anchor=[1, 0.5], ) ax.set_xlabel(self.alias) return ax kernel = kernel.lower()\",\n \"executeSQL( query, title=\\\"Computing the different aggregations.\\\", method=\\\"fetchall\\\", ) for idx,\",\n \"self.parent.__genSQL__(), ), title=\\\"Computing the Store Usage of the vColumn {}.\\\".format(self.alias),\",\n \"h will be picked or computed) ax: Matplotlib axes object,\",\n \"= \\\"NULL\\\" if (elem[1] == None) else str(elem[1]) new_column =\",\n \"------- vDataFrame self.parent See Also -------- vDataFrame[].drop_outliers : Drops outliers\",\n \"to gain in performance. The catalog will be updated when\",\n \"func: str, x: float = 2): \\\"\\\"\\\" --------------------------------------------------------------------------- Applies a\",\n \"str(distinct_elements[k]).replace(\\\"'\\\", \\\"''\\\") ) transformations = self.transformations + [(expr, \\\"bool\\\", \\\"int\\\")]\",\n \"object See Also -------- vDataFrame[].bar : Draws the Bar Chart\",\n \"func = str(func) check_types([(\\\"func\\\", func, [str]), (\\\"copy_name\\\", copy_name, [str])]) try:\",\n \"0 limit = \\\" LIMIT {}\\\".format(limit) else: limit = \\\"\\\"\",\n \"of, max_cardinality, h, donut, rose, ax=None, **style_kwds, ) # ---#\",\n \"vDataFrame parent and do not apply it. This parameter is\",\n \"= round(h, 4) elif h > 0.000001: h = round(h,\",\n \"vColumn '{}' was normalized with the method '{}'.\\\".format( self.alias, method\",\n \"bool = True): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using 'unique'\",\n \"'03-11-1993' will filter the data when 'ts' is greater than\",\n \"{};\\\".format( by[0], fun, self.alias, self.parent.__genSQL__(), by[0] ) result = executeSQL(\",\n \"argv[2 * i + 1] ... ELSE argv[n] END Returns\",\n \"vColumn labeled with 0 and 1 (1 meaning global outlier).\",\n \"\\\"[Add Copy]: A copy of the vColumn {} named {}\",\n \"return self.aggregate([\\\"min\\\"]).values[self.alias][0] # ---# def mode(self, dropna: bool = False,\",\n \"index += self.parent.shape()[0] query = \\\"SELECT {}{} FROM {}{} OFFSET\",\n \"= \\\"\\\", \\\"\\\" for category in cat: tmp_query = \\\"\\\"\\\"SELECT\",\n \"\\\"{}::{}\\\".format(\\\"{}\\\", dtype), dtype, get_category_from_vertica_type(ctype=dtype), ) ] self.parent.__add_to_history__( \\\"[AsType]: The vColumn\",\n \"the optimized histogram nbins using Random Forest.\\\", method=\\\"fetchall\\\", ) result\",\n \"max : Maximum of the vColumn 'of'. sum : Sum\",\n \"nbins, [int, float]), ( \\\"method\\\", method, [\\\"auto\\\", \\\"smart\\\", \\\"same_width\\\", \\\"same_freq\\\",\",\n \"that stores all user transformations. If the vDataFrame represents the\",\n \"= False, ax=None, **style_kwds, ): \\\"\\\"\\\" --------------------------------------------------------------------------- Draws the Time\",\n \"pie_type == \\\"donut\\\" else False rose = True if pie_type\",\n \"cat_priority = [cat_priority] check_types( [ (\\\"by\\\", by, [str]), (\\\"max_cardinality\\\", max_cardinality,\",\n \"conj, \\\", \\\".join(all_new_features) ) + \\\".\\\" ) return self.parent one_hot_encode\",\n \"index, ) return executeSQL( query=query, title=\\\"Getting the vColumn element.\\\", method=\\\"fetchfirstelem\\\",\",\n \"-> {}' to '{}'\\\".format( e, func.replace(\\\"{}\\\", \\\"x\\\"), self.alias.replace('\\\"', \\\"\\\") )\",\n \"-------- vDataFrame.aggregate : Computes the vDataFrame input aggregations. \\\"\\\"\\\" check_types([(\\\"x\\\",\",\n \"this file except in compliance with the License. # You\",\n \"in the vColumn. Parameters ---------- n: int, optional Offset. Returns\",\n \"including the 2 quantiles used to draw the Plot. start_date:\",\n \"issue.\\\" ) new_vColumn = vColumn( name, parent=self.parent, transformations=[item for item\",\n \"\\\"\\\"\\\" return self.aggregate([\\\"aad\\\"]).values[self.alias][0] # ---# def abs(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Applies\",\n \"ParameterError( \\\"numh is only available on type numeric|date\\\" ) if\",\n \"relation. vColumns simplify several processes with its abstractions. Parameters ----------\",\n \"self.alias: result}) for elem in values: for i in range(len(values[elem])):\",\n \"[bool]), ] ) method = method.lower() if self.isnum() and method\",\n \"): \\\"\\\"\\\" --------------------------------------------------------------------------- Discretizes the vColumn using the input list.\",\n \"{}\\\".format( bin_spatial_to_str(self.category(), self.alias), self.alias, self.parent.__genSQL__(), self.alias, self.alias, self.alias, ) else:\",\n \"elem in catalog: self.catalog[elem] = catalog[elem] # ---# def __getitem__(self,\",\n \"for Normalization\\\") return self.parent # ---# def nsmallest(self, n: int\",\n \"will return the transformation used instead of the parent vDataFrame.\",\n \") response_cat = self.parent[y].distinct() response_cat.sort() assert response_cat == [0, 1],\",\n \"memory usage (byte) See Also -------- vDataFrame.memory_usage : Returns the\",\n \"'minute' 'hour'... start: bool, optional If set to True, the\",\n \"return self.apply( func=\\\"REGEXP_COUNT({}, '{}') > 0\\\".format(\\\"{}\\\", pat.replace(\\\"'\\\", \\\"''\\\")) ) #\",\n \"0, }, ) setattr(self.parent, name, new_vColumn) setattr(self.parent, name.replace('\\\"', \\\"\\\"), new_vColumn)\",\n \"aggregations. \\\"\\\"\\\" return self.aggregate([\\\"kurtosis\\\"]).values[self.alias][0] kurt = kurtosis # ---# def\",\n \"be computed. pie_type: str, optional The type of pie chart.\",\n \"a function to the input vColumn. \\\"\\\"\\\" check_types([(\\\"n\\\", n, [int,\",\n \"verticapy.plot import gen_cmap kwargs[\\\"cmap\\\"] = gen_cmap()[0] else: if not (\\\"color\\\"\",\n \"vColumn using 'aad' (Average Absolute Deviation). Returns ------- float aad\",\n \"\\\"float\\\"]: warning_message = ( \\\"label_encode is only available for categorical\",\n \": SQL code generation will be slower if the vDataFrame\",\n \"elif expr: new_column = \\\"COALESCE({}, {})\\\".format(\\\"{}\\\", expr) elif method ==\",\n \"self.parent.search( \\\"{} = '{}'\\\".format(self.parent[by].alias, column) )[self.alias].density( bandwidth=bandwidth, kernel=kernel, nbins=nbins, xlim=(xmin,\",\n \"the vColumn memory usage. Returns ------- float vColumn memory usage\",\n \"most occurent elements to return. Returns ------- tablesample An object\",\n \"the vColumn with Label Encoding. vDataFrame[].get_dummies : Encodes the vColumn\",\n \"ax Matplotlib axes object See Also -------- vDataFrame.donut : Draws\",\n \"# ---# def aad(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using\",\n \"(the \\\"License\\\"); # You may not use this file except\",\n \"self.transformations += [(func, ctype, category)] self.parent.__update_catalog__(erase=True, columns=[self.alias]) self.parent.__add_to_history__( \\\"[Apply]: The\",\n \"THEN argv[2 * i + 1] ... ELSE argv[n] END\",\n \"False else the lower and upper ZScores. threshold: float, optional\",\n \"bool = True): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns the k most occurent\",\n \"is boolean. vDataFrame[].isdate : Returns True if the vColumn category\",\n \"+ tmp_query + rp] query = \\\"WITH vdf_table AS (SELECT\",\n \"example, to check if Badr and Fouad are in the\",\n \"\\\"{}\\\"), \\\"int\\\", \\\"float\\\") ] self.parent.__update_catalog__(erase=True, columns=[self.alias]) self.parent.__add_to_history__( \\\"[Mean Encode]: The\",\n \"If empty, an optimized h will be computed. pie_type: str,\",\n \"datetime ...), the parameter 'x' will represent the number of\",\n \"] self.parent.__add_to_history__( \\\"[AsType]: The vColumn {} was converted to {}.\\\".format(\",\n \"'approx_25%', APPROXIMATE_PERCENTILE ({3}{4} USING PARAMETERS percentile = 0.5) AS 'approx_50%',\",\n \"of the vColumn. transformations, str : List of the different\",\n \"{} using a Robust Z-Score - The MAD is null\",\n \"Maximum of the vColumn 'of'. sum : Sum of the\",\n \"[], include_lowest: bool = True, right: bool = True, ):\",\n \"Discretizes the vColumn. vDataFrame[].label_encode : Encodes the vColumn with Label\",\n \"will increase the precision but will also increase the time\",\n \"if the vColumn is numerical , 'categorical' otherwise. categorical :\",\n \"DB type. \\\"\\\"\\\" return self.transformations[-1][1].lower() dtype = ctype # ---#\",\n \") ) query += [lp + tmp_query + rp] query\",\n \"raise drop(tmp_view_name, method=\\\"view\\\") drop(tmp_model_name, method=\\\"model\\\") result = [self.min()] + result\",\n \"Returns ------- vDataFrame self.parent See Also -------- vDataFrame.drop: Drops the\",\n \"item in executeSQL( query=query, title=\\\"Computing the average of the {}'s\",\n \"different records. For example, to check if Badr and Fouad\",\n \"------- str vColumn DB type. \\\"\\\"\\\" return self.transformations[-1][1].lower() dtype =\",\n \"(\\\"plot_median\\\", plot_median, [bool]), ] ) self.parent.are_namecols_in(ts) ts = self.parent.format_colnames(ts) from\",\n \"a vDataFrame column if the method is 'cat_stats'\\\" ) distinct_count,\",\n \"vColumn. \\\"\\\"\\\" check_types([(\\\"to_replace\\\", to_replace, [str]), (\\\"value\\\", value, [str])]) return self.apply(\",\n \") drop(tmp_model_name, method=\\\"model\\\") if self.parent[response].category() == \\\"float\\\": model = RandomForestRegressor(tmp_model_name)\",\n \": Encodes the vColumn using a user-defined encoding. vDataFrame[].discretize :\",\n \"taking advantage Vertica’s # speed and built-in analytics and machine\",\n \"PARAMETERS percentile = 0.75) AS Q3, MAX({}) AS max FROM\",\n \"Subtracts the input element from the vColumn. Parameters ---------- x:\",\n \"'max' (Maximum). Returns ------- float/str maximum See Also -------- vDataFrame.aggregate\",\n \"[\\\"auto\\\", \\\"numerical\\\", \\\"categorical\\\", \\\"cat_stats\\\"]), (\\\"max_cardinality\\\", max_cardinality, [int, float]), (\\\"numcol\\\", numcol,\",\n \"vDataFrame.apply : Applies functions to the input vColumns. vDataFrame.applymap :\",\n \"size to convert to use to convert the vColumn. If\",\n \"numerical. Optimized h will be computed if the parameter is\",\n \"# ---# def product(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using\",\n \"EmptyParameter( \\\"The parameter 'name' must not be empty\\\" ) assert\",\n \"the values lesser than the lower bound to the lower\",\n \"if of: self.parent.are_namecols_in(of) of = self.parent.format_colnames(of) from verticapy.plot import pie\",\n \"Parameters ---------- y: str Response vColumn. nbins: int, optional Maximum\",\n \"elem in enumerate(result): result[idx][0] = ( \\\"NULL\\\" if (elem[0] ==\",\n \"= ( result[0], result[3], result[4], result[6], result[7], ) elif self.isdate():\",\n \"+ nth_elems + [str(count)]) ) query = \\\"SELECT {} FROM\",\n \"VerticaPy is a Python library with scikit-like functionality for conducting\",\n \"|~) _ _| _ /~\\\\ _ |. # |_)\\\\/ |_)(_|(_||\",\n \"used for the plot. gaussian : Gaussian kernel. logistic :\",\n \"{}{} LIMIT {} OFFSET {}\\\".format( bin_spatial_to_str(self.category(), self.alias), self.alias, self.parent.__genSQL__(), self.parent.__get_last_order_by__(),\",\n \"drop_first: bool, optional Drops the first dummy to avoid the\",\n \"!= None: new_column = \\\"COALESCE({}, '{}')\\\".format(\\\"{}\\\", val) elif expr: new_column\",\n \"mean_alpha == None: mean_alpha = \\\"NULL\\\" if mean_1_alpha == None:\",\n \"--------------------------------------------------------------------------- Aggregates the vColumn using 'avg' (Average). Returns ------- float\",\n \") # ---# def spider( self, by: str = \\\"\\\",\",\n \"+= self.parent.shape()[0] if isinstance(index_stop, int): if index_stop < 0: index_stop\",\n \"{}) AS {} FROM {}) VERTICAPY_OPTIMAL_H_TABLE\\\".format( min_date, self.alias, self.alias, self.parent.__genSQL__()\",\n \"optional Number of nbins. If empty, an optimized number of\",\n \"abs : absolute value acos : trigonometric inverse cosine asin\",\n \"{})\\\".format(\\\"{}\\\", val) elif (len(by) == 1) and (self.parent[by[0]].nunique() < 50):\",\n \"Area Plot. step: bool, optional If set to True, draw\",\n \"{}\\\".format( \\\"'{}'\\\".format(str(elem[0]).replace(\\\"'\\\", \\\"''\\\")) if elem[0] != None else \\\"NULL\\\", elem[1]\",\n \"it returns the new vDataFrame of the search. Parameters ----------\",\n \"{} FROM {} WHERE {} IS NOT NULL LIMIT 20\\\".format(\",\n \"from the vColumn (only if the vColumn type is date\",\n \"fun, \\\"{}\\\", \\\", \\\".join(by) ) elif method in (\\\"ffill\\\", \\\"pad\\\",\",\n \"vColumn using as lower bound quantile(alpha) and as upper bound\",\n \"include_lowest: bool = True, right: bool = True, ): \\\"\\\"\\\"\",\n \"else result[0][0] if not (dropna): n = \\\"\\\" if (n\",\n \"Encodes the vColumn using a user-defined encoding. Parameters ---------- argv:\",\n \"BY {})\\\".format( self.alias, \\\", \\\".join(by) ), \\\"STDDEV({}) OVER (PARTITION BY\",\n \"the data. count : Number of elements. density : Percentage\",\n \"parent=self.parent, transformations=[item for item in self.transformations], catalog=self.catalog, ) setattr(self.parent, name,\",\n \"/ MILLENNIUM / MILLISECONDS / MINUTE / MONTH / QUARTER\",\n \"\\\".join(by) ) elif method in (\\\"ffill\\\", \\\"pad\\\", \\\"bfill\\\", \\\"backfill\\\"): assert\",\n \"1 else \\\" was \\\" if verticapy.options[\\\"print_info\\\"]: print(\\\"{} element{}filled.\\\".format(total, conj))\",\n \": Creates a copy of the vColumn. \\\"\\\"\\\" check_types([(\\\"new_name\\\", new_name,\",\n \"'smart'.\\\" ) assert response, ParameterError( \\\"Parameter 'response' can not be\",\n \"one of the following: CENTURY / DAY / DECADE /\",\n \"< max_cardinality + 1) and (method != \\\"numerical\\\")) or not\",\n \"in cat: tmp_query = \\\"\\\"\\\"SELECT '{0}' AS 'index', COUNT({1}) AS\",\n \"True, the method will return the transformation used instead of\",\n \"check_types( [ (\\\"ts\\\", ts, [str]), (\\\"q\\\", q, [tuple]), ( \\\"start_date\\\",\",\n \"to True, draw a Step Plot. ax: Matplotlib axes object,\",\n \"= True, ): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using 'median'.\",\n \"and 1 (1 meaning global outlier). \\\"\\\"\\\" check_types( [ (\\\"alpha\\\",\",\n \"start_date, [str, datetime.datetime, datetime.date]), (\\\"end_date\\\", end_date, [str, datetime.datetime, datetime.date]), (\\\"area\\\",\",\n \"title=\\\"Computing the Store Usage of the vColumn {}.\\\".format(self.alias), method=\\\"fetchfirstelem\\\", )\",\n \"int, float], ), ( \\\"end_date\\\", end_date, [str, datetime.datetime, datetime.date, int,\",\n \"logarithm mod : remainder of a division operation pow :\",\n \"the vColumn using 'max' (Maximum). Returns ------- float/str maximum See\",\n \"= float(values[elem][i]) return tablesample(values) # ---# def discretize( self, method:\",\n \"\\\"varchar\\\", \\\"text\\\") if (self.isnum() and method == \\\"same_freq\\\") or (\",\n \"query = \\\"SELECT {}::{} AS {} FROM {} WHERE {}\",\n \"return self.apply(func=expr) # ---# def astype(self, dtype: str): \\\"\\\"\\\" ---------------------------------------------------------------------------\",\n \"\\\"count\\\" in sauv: self.catalog[\\\"count\\\"] = int(sauv[\\\"count\\\"]) + total self.catalog[\\\"percent\\\"] =\",\n \"= [self.min()] + result + [self.max()] elif method == \\\"topk\\\":\",\n \"optional Set the x limits of the current axes. ax:\",\n \"merging category when using the 'topk' method. RFmodel_params: dict, optional\",\n \"if pre_comp != \\\"VERTICAPY_NOT_PRECOMPUTED\\\": return pre_comp store_usage = executeSQL( \\\"SELECT\",\n \"cosh : hyperbolic cosine cot : trigonometric cotangent exp :\",\n \"---# def aggregate(self, func: list): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn\",\n \"Line2D( [0], [0], color=updated_dict(param, style_kwds, idx)[\\\"color\\\"], lw=4, ), ] ax.set_title(\\\"KernelDensity\\\")\",\n \"IN ({}) THEN {} || '' ELSE '{}' END)\\\".format( bin_spatial_to_str(self.category()),\",\n \"= [val] val += list(args) check_types([(\\\"val\\\", val, [list])]) val =\",\n \"def ctype(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns the vColumn DB type. Returns\",\n \") order_by_ts = \\\", \\\".join([quote_ident(column) + desc for column in\",\n \"apply it. This parameter is very useful for testing to\",\n \"\\\"\\\" if index < 0: index += self.parent.shape()[0] query =\",\n \"# ---# def date_part(self, field: str): \\\"\\\"\\\" --------------------------------------------------------------------------- Extracts a\",\n \": trigonometric cotangent exp : exponential function floor : value\",\n \"events = 0 THEN 0 ELSE (pt_non_events - pt_events) *\",\n \"{} AND {}) THEN {} ELSE NULL END)\\\".format( \\\"{}\\\", p_alpha,\",\n \"-------- vDataFrame[].decode : Encodes the vColumn with a user defined\",\n \"xlim_tmp = [xlim] else: xlim_tmp = [] model = KernelDensity(\",\n \"+ 1) and (method != \\\"numerical\\\")) or not (is_numeric) or\",\n \": Fills the outliers in the vColumn. vDataFrame.outliers : Adds\",\n \"f\\\"A vColumn has already the alias {new_name}.\\\\nBy changing the parameter\",\n \"self.parent.__update_catalog__(erase=True, columns=[self.alias]) try: if \\\"count\\\" in sauv: self.catalog[\\\"count\\\"] = sauv[\\\"count\\\"]\",\n \"---# def add_copy(self, name: str): \\\"\\\"\\\" --------------------------------------------------------------------------- Adds a copy\",\n \"Draws the spider plot of the input vColumn based on\",\n \") # ---# def product(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn\",\n \"(vColumn_075 - vColumn_025) / (count) ** (1.0 / 3.0), 1e-99)\",\n \"lower outliers by their respective average. null : Replaces the\",\n \"[int, float]), (\\\"cat_priority\\\", cat_priority, [list]), ] ) if by: self.parent.are_namecols_in(by)\",\n \"is date like (date, datetime ...), the parameter 'x' will\",\n \"* FROM {} LIMIT 10\\\".format( self.parent.__genSQL__(force_columns=force_columns) ), print_time_sql=False, ) self.parent._VERTICAPY_VARIABLES_[\\\"columns\\\"].remove(self.alias)\",\n \"import math, re, decimal, warnings, datetime from collections.abc import Iterable\",\n \"the vColumn is boolean. vDataFrame[].isnum : Returns True if the\",\n \"else: best_h = max(sturges, fd) self.parent.__update_catalog__({\\\"index\\\": [\\\"numh\\\"], self.alias: [best_h]}) if\",\n \"h <= 0: if nbins <= 0: h = self.numh()\",\n \"Returns ------- float aad See Also -------- vDataFrame.aggregate : Computes\",\n \"0 THEN 0 ELSE (pt_non_events - pt_events) * ZEROIFNULL(LN(pt_non_events /\",\n \"width. Parameters ---------- method: str, optional Method to use to\",\n \"Aggregates the vColumn using 'min' (Minimum). Returns ------- float/str minimum\",\n \"used as categorical. The less frequent elements will be gathered\",\n \"one unique category. h: float, optional The interval size to\",\n \"---------- limit: int, optional Number of elements to display. Returns\",\n \"float, approx: bool = True): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn\",\n \"result.values[\\\"non_events\\\"] += [sum(result[\\\"non_events\\\"])] result.values[\\\"events\\\"] += [sum(result[\\\"events\\\"])] result.values[\\\"pt_non_events\\\"] += [\\\"\\\"] result.values[\\\"pt_events\\\"]\",\n \"vDataFrame input aggregations. \\\"\\\"\\\" return self.aggregate([\\\"aad\\\"]).values[self.alias][0] # ---# def abs(self):\",\n \"encoding\\\" ) max_floor = len(self.parent[response].transformations) - len( self.transformations ) for\",\n \"1\\\".format( cmax, cmin, self.parent.__genSQL__() ), print_time_sql=False, ) except: cmax, cmin\",\n \"\\\\_\\\\ \\\\ \\\\_\\\\ \\\\ \\\\_\\\\\\\\\\\"\\\\_\\\\ # \\\\/_/ \\\\/_____/ \\\\/_____/ \\\\/_____/\",\n \"other statistical information. Parameters ---------- k: int, optional Number of\",\n \"by: str, optional vColumn to use to partition the data.\",\n \"LIMIT 1\\\".format( new_column.format(self.alias), self.parent.__genSQL__() ), print_time_sql=False, ) except: new_column =\",\n \"not (\\\"color\\\" in kwargs): from verticapy.plot import gen_colors kwargs[\\\"color\\\"] =\",\n \"pat, [str])]) return self.apply( func=\\\"REGEXP_COUNT({}, '{}') > 0\\\".format(\\\"{}\\\", pat.replace(\\\"'\\\", \\\"''\\\"))\",\n \"vDataFrame memory usage. \\\"\\\"\\\" import sys total = ( sys.getsizeof(self)\",\n \"Draws the time series. \\\"\\\"\\\" check_types( [ (\\\"ts\\\", ts, [str]),\",\n \"aggregations. \\\"\\\"\\\" return self.aggregate(func=[\\\"prod\\\"]).values[self.alias][0] prod = product # ---# def\",\n \"None: mean_alpha = \\\"NULL\\\" if mean_1_alpha == None: mean_alpha =\",\n \"+ by) by = self.parent.format_colnames(by) if method == \\\"auto\\\": method\",\n \"by, start_date, end_date, area, step, ax=ax, **style_kwds, ) # ---#\",\n \"vColumn category is date. See Also -------- vDataFrame[].isbool : Returns\",\n \"DESC\\\" ).format(self.alias, max_cardinality + 1) query = \\\"WITH vdf_table AS\",\n \"in Vertica, taking advantage Vertica’s # speed and built-in analytics\",\n \"mean_encode(self, response: str): \\\"\\\"\\\" --------------------------------------------------------------------------- Encodes the vColumn using the\",\n \"in result] elif self.isnum() and method in (\\\"same_width\\\", \\\"auto\\\"): if\",\n \"use to compute the aggregation. h: int/float/tuple, optional Interval width\",\n \"max_cardinality: query += ( \\\"UNION ALL (SELECT 'Others', SUM(count) FROM\",\n \"the vColumn using the input method. Parameters ---------- method: str,\",\n \"The field to extract. It must be one of the\",\n \"of the vColumn. Returns ------- str/float/int vColumn nth most occurent\",\n \"(isinstance(val, Iterable)): val = [val] val += list(args) check_types([(\\\"val\\\", val,\",\n \"\\\"zscore\\\": self.catalog[\\\"mean\\\"] = 0 self.catalog[\\\"std\\\"] = 1 elif method ==\",\n \"(\\\"mean\\\", \\\"median\\\") or isinstance(val, float): category, ctype = \\\"float\\\", \\\"float\\\"\",\n \"Renames the vColumn by dropping the current vColumn and creating\",\n \"be able to solve this issue.\\\" ) new_vColumn = vColumn(\",\n \"= self.parent.format_colnames(of) from verticapy.plot import hist return hist(self, method, of,\",\n \"\\\\ \\\\__| \\\\ \\\\_____\\\\ \\\\ \\\\_____\\\\ \\\\ \\\\_____\\\\ \\\\ \\\\_____\\\\\",\n \"arithmetic square root tan : trigonometric tangent tanh : hyperbolic\",\n \") elif method == \\\"mean\\\": query = \\\"WITH vdf_table AS\",\n \"aggregation. aad : average absolute deviation approx_unique : approximative cardinality\",\n \"for the regular expression in each record of the vColumn.\",\n \"\\\"public\\\" name = gen_tmp_name(schema=schema, name=\\\"kde\\\") if isinstance(xlim, (tuple, list)): xlim_tmp\",\n \"cvar : conditional value at risk dtype : vColumn type\",\n \"(SELECT 'Others', SUM(count) FROM (SELECT COUNT(*) AS count\\\" \\\" FROM\",\n \"topk_percent : kth most occurent element density unique : cardinality\",\n \"int(sauv[\\\"count\\\"]) + total self.catalog[\\\"percent\\\"] = ( 100 * (int(sauv[\\\"count\\\"]) +\",\n \"stddev = \\\"DECODE({}, {}, NULL)\\\".format( by[0], \\\", \\\".join( [ \\\"{},\",\n \"- 1 ) result = executeSQL( query=query, title=\\\"Computing the optimized\",\n \"- vColumn_025) / (count) ** (1.0 / 3.0), 1e-99) if\",\n \"result[3], result[4], result[6], result[7], ) elif self.isdate(): min_date = self.min()\",\n \"tanh : hyperbolic tangent x: int/float, optional If the function\",\n \"using the mean encoding of a response. \\\"\\\"\\\" check_types( [\",\n \"Random Forest.\\\", method=\\\"fetchall\\\", ) result = [elem[0] for elem in\",\n \"the vColumn using the input functions. Parameters ---------- func: list\",\n \"speed and built-in analytics and machine learning features. It supports\",\n \"* COUNT(*) / {} AS percent FROM {}{} GROUP BY\",\n \"-------- vDataFrame.filter: Filters the data using the input expression. \\\"\\\"\\\"\",\n \"vColumns from the vDataFrame. \\\"\\\"\\\" check_types([(\\\"add_history\\\", add_history, [bool])]) try: parent\",\n \"except: new_column = \\\"COALESCE({}, {}({}) OVER (PARTITION BY {}))\\\".format( \\\"{}\\\",\",\n \"regular expression in each record of the vColumn. The vColumn\",\n \"the input type. \\\"\\\"\\\" check_types([(\\\"dtype\\\", dtype, [str])]) try: query =\",\n \"lowest element of the list will be included. right: bool,\",\n \"elem[0] != None else \\\"NULL\\\", elem[2] if elem[2] != None\",\n \"Returns True if the vColumn is boolean, False otherwise. Returns\",\n \"vColumn will be transformed. Parameters ---------- to_replace: str Regular expression\",\n \"sin : trigonometric sine sinh : hyperbolic sine sqrt :\",\n \"mean_1_alpha, \\\"{}\\\" ) ) return self.parent # ---# def fillna(\",\n \"Returns True if the vColumn category is date. vDataFrame[].isnum :\",\n \"def median( self, approx: bool = True, ): \\\"\\\"\\\" ---------------------------------------------------------------------------\",\n \"kernel. silverman : Silverman kernel. nbins: int, optional Maximum number\",\n \"{}) / ({})\\\".format(\\\"{}\\\", med, mad), \\\"float\\\", \\\"float\\\", ) ] else:\",\n \"'quantile'. Parameters ---------- x: float A float between 0 and\",\n \"\\\\ \\\\_____\\\\ \\\\ \\\\_\\\\ \\\\ \\\\_\\\\ \\\\ \\\\_\\\\\\\\\\\"\\\\_\\\\ # \\\\/_/\",\n \"copy with the specified name. \\\\u26A0 Warning : SQL code\",\n \"skewness # ---# def slice(self, length: int, unit: str =\",\n \"the vColumn. vDataFrame[].label_encode : Encodes the vColumn with Label Encoding.\",\n \"---# def median( self, approx: bool = True, ): \\\"\\\"\\\"\",\n \"mad) minmax : Normalization using the MinMax (min and max).\",\n \"new_column = \\\"COALESCE({}, LAST_VALUE({} IGNORE NULLS) OVER ({} ORDER BY\",\n \"0: h = self.numh() else: h = (self.max() - self.min())\",\n \"bar( self, method: str = \\\"density\\\", of: str = \\\"\\\",\",\n \"already the alias of one of the dummies ({name}).\\\\n\\\" \\\"It\",\n \"verticapy.options[\\\"temp_schema\\\"] if not (schema): schema = \\\"public\\\" tmp_view_name = gen_tmp_name(schema=schema,\",\n \"self.parent.__get_catalog_value__(self.alias, \\\"numh\\\") if pre_comp != \\\"VERTICAPY_NOT_PRECOMPUTED\\\": return pre_comp assert self.isnum()\",\n \"str = \\\"\\\"): \\\"\\\"\\\" --------------------------------------------------------------------------- Applies a function to the\",\n \"), (\\\"expr\\\", expr, [str]), (\\\"by\\\", by, [list]), (\\\"order_by\\\", order_by, [list]),\",\n \"1\\\".format( alpha, self.alias, alpha, self.alias, self.parent.__genSQL__() ) p_alpha, p_1_alpha =\",\n \"{}) THEN {} ELSE NULL END)\\\".format( \\\"{}\\\", p_alpha, p_1_alpha, \\\"{}\\\"\",\n \"method used for the plot. gaussian : Gaussian kernel. logistic\",\n \"in each record of the vColumn. The vColumn will be\",\n \"{}, \\\"regr_sxx\\\": {}, \\\"regr_sxy\\\": {}, \\\"regr_syy\\\": {}, } for elem\",\n \"specified number of decimal places sign : arithmetic sign sin\",\n \"the lower and upper ZScores. threshold: float, optional Uses the\",\n \"+ 1] if right: op1, op2, close_l, close_r = \\\"<\\\",\",\n \"lp, rp = \\\"(\\\", \\\")\\\" else: lp, rp = \\\"\\\",\",\n \"desc for column in order_by]) new_column = \\\"COALESCE({}, LAST_VALUE({} IGNORE\",\n \"vColumn to use to compute the aggregation. h: int/float/tuple, optional\",\n \"optional Maximum number of points to use to evaluate the\",\n \"Encoding]: Label Encoding was applied to the vColumn {} using\",\n \"mean : Replaces the upper and lower outliers by their\",\n \"self.transformations + [(expr, \\\"bool\\\", \\\"int\\\")] new_vColumn = vColumn( name, parent=self.parent,\",\n \"a vColumn can be seen as one column of that\",\n \"[elem for elem in order_by] for elem in all_partition: if\",\n \"expr = \\\"{}({}, {})\\\".format(func.upper(), \\\"{}\\\", x) return self.apply(func=expr) # ---#\",\n \"---------- func: list List of the different aggregation. aad :\",\n \"Encodes the vColumn with user defined Encoding. vDataFrame[].discretize : Discretizes\",\n \"[ \\\"{}, {}\\\".format( \\\"'{}'\\\".format(str(elem[0]).replace(\\\"'\\\", \\\"''\\\")) if elem[0] != None else\",\n \"n smallest elements in the vColumn. \\\"\\\"\\\" check_types([(\\\"n\\\", n, [int,\",\n \"LIMIT 0\\\".format( func.replace(\\\"{}\\\", self.alias), self.parent.__genSQL__(), self.alias, ), \\\"apply_test_feature\\\", ) except:\",\n \"--------------------------------------------------------------------------- Draws the Geospatial object. Parameters ---------- *args / **kwargs\",\n \"License is distributed on an \\\"AS IS\\\" BASIS, # WITHOUT\",\n \"in case of discretization using the method 'same_freq'\\\" ) count\",\n \"vColumn to the parent vDataFrame. Parameters ---------- name: str Name\",\n \"features. use_numbers_as_suffix: bool, optional Uses numbers as suffix instead of\",\n \"If empty, an optimized number of bins will be computed.\",\n \"It must be one of the following: CENTURY / DAY\",\n \"= \\\"Reads {}.\\\".format(self.alias) tail = to_tablesample( \\\"SELECT {} AS {}\",\n \"if distinct_elements not in ([0, 1], [1, 0]) or self.isbool():\",\n \"not be considered during the computation. Returns ------- tablesample An\",\n \"Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].date_part : Extracts\",\n \"(date, datetime ...), the parameter 'x' will represent the number\",\n \"parent vDataFrame. Parameters ---------- name: str Name of the copy.\",\n \"The aggregations used are the median and two input quantiles.\",\n \"[str, datetime.datetime, datetime.date]), (\\\"end_date\\\", end_date, [str, datetime.datetime, datetime.date]), (\\\"area\\\", area,\",\n \"------- ax Matplotlib axes object See Also -------- vDataFrame.plot :\",\n \"of the vColumn. \\\"\\\"\\\" check_types([(\\\"limit\\\", limit, [int, float]), (\\\"offset\\\", offset,\",\n \"if check: self.parent.are_namecols_in(column) column = self.parent.format_colnames(column) columns += [column] if\",\n \"object See Also -------- vDataFrame.bar : Draws the Bar Chart\",\n \"{ \\\"index\\\": [\\\"name\\\", \\\"dtype\\\"] + index, \\\"value\\\": [self.alias, self.ctype()] +\",\n \"numerical and Mode for the categorical vColumns. bfill : Back\",\n \"skewness(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using 'skewness'. Returns -------\",\n \"argv[2 * i] THEN argv[2 * i + 1] ...\",\n \"2 DESC LIMIT {}) VERTICAPY_SUBTABLE ORDER BY split_value::float\\\".format( \\\" UNION\",\n \"ELSE ZEROIFNULL(LN(pt_non_events / NULLIFZERO(pt_events))) END AS woe, CASE WHEN non_events\",\n \"executeSQL( query=query, title=\\\"Computing the average of the {}'s lower and\",\n \"= ( 100 * (int(sauv[\\\"count\\\"]) + total) / self.parent.shape()[0] )\",\n \"force_columns.remove(self.alias) executeSQL( \\\"SELECT * FROM {} LIMIT 10\\\".format( self.parent.__genSQL__(force_columns=force_columns) ),\",\n \"lower bound itself and the values higher than the upper\",\n \"catalog[elem] # ---# def __getitem__(self, index): if isinstance(index, slice): assert\",\n \"max_floor = self.parent.get_columns(), 0 for column in all_cols: try: if\",\n \"Type casting.\\\") self.transformations += [ ( \\\"{}::{}\\\".format(\\\"{}\\\", dtype), dtype, get_category_from_vertica_type(ctype=dtype),\",\n \"not apply it. This parameter is very useful for testing\",\n \"value. Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].str_contains :\",\n \"\\\"auto\\\": method = \\\"mean\\\" if (self.isnum() and self.nunique(True) > 6)\",\n \"different categories to normalize.\\\", method=\\\"fetchall\\\", ) for i in range(len(result)):\",\n \"bool = False, ): \\\"\\\"\\\" --------------------------------------------------------------------------- Encodes the vColumn with\",\n \"optional Maximum number of nbins used for the discretization (must\",\n \"ts_plot return ts_plot( self, ts, by, start_date, end_date, area, step,\",\n \"to True, the information will be stored in the vDataFrame\",\n \"to a specified number of decimal places sign : arithmetic\",\n \"self.alias, alpha, self.alias, self.parent.__genSQL__() ) p_alpha, p_1_alpha = executeSQL( query=query,\",\n \"Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].str_contains : Verifies\",\n \"self.apply(func=expr) # ---# def astype(self, dtype: str): \\\"\\\"\\\" --------------------------------------------------------------------------- Converts\",\n \"self.parent.__genSQL__(), self.parent.__get_last_order_by__(), limit, offset, ), title=title, ) tail.count = self.parent.shape()[0]\",\n \"ts, [str]), (\\\"q\\\", q, [tuple]), ( \\\"start_date\\\", start_date, [str, datetime.datetime,\",\n \"SUM(count) FROM (SELECT COUNT(*) AS count\\\" \\\" FROM vdf_table WHERE\",\n \"optional Returns the transformation instead of the vDataFrame parent and\",\n \"-------- vDataFrame[].decode : Encodes the vColumn with user defined Encoding.\",\n \"a user defined Encoding. vDataFrame[].discretize : Discretizes the vColumn. vDataFrame[].get_dummies\",\n \"\\\"log\\\", \\\"log10\\\", \\\"mod\\\", \\\"pow\\\", \\\"round\\\", \\\"sign\\\", \\\"sin\\\", \\\"sinh\\\", \\\"sqrt\\\", \\\"tan\\\",\",\n \"use to order the data. The vColumn type must be\",\n \"i in range(len(values[elem])): if isinstance(values[elem][i], decimal.Decimal): values[elem][i] = float(values[elem][i]) return\",\n \"'smart'. return_enum_trans: bool, optional Returns the transformation instead of the\",\n \"Returns the head of the vColumn. Parameters ---------- limit: int,\",\n \"to use to evaluate the approximate density function. Increasing this\",\n \"optional Uses numbers as suffix instead of the vColumns categories.\",\n \"to use to transform the vColumn. abs : absolute value\",\n \": Uses the Random Forest on a response column to\",\n \"result = executeSQL( query, title=\\\"Computing the different aggregations.\\\", method=\\\"fetchall\\\", )\",\n \"number of distinct elements for vColumns 1 and 2 to\",\n \"depth of 10. response: str, optional Response vColumn when method\",\n \"elements. \\\"\\\"\\\" check_types([(\\\"n\\\", n, [int, float])]) query = \\\"SELECT *\",\n \"the License. # # |_ |~) _ _| _ /~\\\\\",\n \"computation. max_cardinality: int, optional Cardinality threshold to use to determine\",\n \"str Response vColumn. nbins: int, optional Maximum number of nbins\",\n \"date like. Optimized h will be computed if the parameter\",\n \"from matplotlib.lines import Line2D colors = gen_colors() if not xlim:\",\n \"USING PARAMETERS percentile = 0.75) AS Q3, MAX({}) AS max\",\n \"nbins: int, optional Number of nbins. If empty, an optimized\",\n \"self.parent.__add_to_history__( \\\"[Get Dummies]: One hot encoder was applied to the\",\n \"if self.isnum(): result = ( self.parent.describe( method=\\\"numerical\\\", columns=[self.alias], unique=False )\",\n \"\\\"_\\\") ) ) assert not (self.parent.is_colname_in(name)), NameError( f\\\"A vColumn has\",\n \"AS min, APPROXIMATE_PERCENTILE({} USING PARAMETERS percentile = 0.25) AS Q1,\",\n \"-------- vDataFrame.donut : Draws the donut chart of the vColumn\",\n \"function to the input vColumn. \\\"\\\"\\\" check_types([(\\\"n\\\", n, [int, float])])\",\n \"result # ---# def kurtosis(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn\",\n \"\\\"\\\"\\\" check_types( [ (\\\"length\\\", length, [int, float]), (\\\"unit\\\", unit, [str]),\",\n \"of non-missing elements q% : q quantile (ex: 50% for\",\n \"Normalization using the MinMax (min and max). (x - min)\",\n \"to evaluate the approximate density function. Increasing this parameter will\",\n \"exp : exponential function floor : value down to the\",\n \"offset, ), title=title, ) tail.count = self.parent.shape()[0] tail.offset = offset\",\n \"PARAMETERS percentile = 0.1) AS 'approx_10%', APPROXIMATE_PERCENTILE ({3}{4} USING PARAMETERS\",\n \"the predictive power of an independent variable in relation to\",\n \"str The new vColumn alias. Returns ------- vDataFrame self.parent See\",\n \"query = \\\"\\\"\\\"(SELECT {0} || '', COUNT(*) FROM vdf_table GROUP\",\n \"p_1_alpha, mean_1_alpha, \\\"{}\\\" ) ) return self.parent # ---# def\",\n \"float])]) return self.apply(func=\\\"{} * ({})\\\".format(\\\"{}\\\", x)) # ---# def nlargest(self,\",\n \"a part of the vColumn. \\\"\\\"\\\" return self.iloc(limit=limit) # ---#\",\n \"QueryError(\\\"{}\\\\nAn Error happened during the filling.\\\".format(e)) if total > 0:\",\n \"Increasing this parameter will increase the precision but will also\",\n \"int = 0): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns a part of the\",\n \"deviation). Returns ------- float mad See Also -------- vDataFrame.aggregate :\",\n \"LIMIT 1\\\".format( self.alias, cast, self.parent.__genSQL__(), self.parent.__get_last_order_by__(), index, ) return executeSQL(\",\n \"if stddev == 0: warning_message = \\\"Can not normalize {}\",\n \"vDataFrame of the search. Parameters ---------- val: list List of\",\n \"\\\"float\\\" else \\\"\\\" if index < 0: index += self.parent.shape()[0]\",\n \"{} FROM {} WHERE {} IS NOT NULL GROUP BY\",\n \"ceil : value up to the next whole number cos\",\n \"\\\"AS IS\\\" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY\",\n \"kurtosis(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using 'kurtosis'. Returns -------\",\n \"of the record is greater than the threshold it will\",\n \"rp = \\\"\\\", \\\"\\\" for category in cat: tmp_query =\",\n \"deviation topk : kth most occurent element (ex: top1 for\",\n \"lower bound to the lower bound itself and the values\",\n \"+= list(args) check_types([(\\\"val\\\", val, [list])]) val = {self.alias: val} return\",\n \"find the most relevant interval to use for the discretization.\",\n \"the max and the min sem : standard error of\",\n \"COUNT({}) AS NAs, MIN({}) AS min, APPROXIMATE_PERCENTILE({} USING PARAMETERS percentile\",\n \"\\\"0ifnull\\\"]: max_floor = 0 all_partition = by if method in\",\n \"0.000001: h = round(h, 6) if self.category() == \\\"int\\\": h\",\n \"{} (response = {}).\\\".format(self.alias, y) result = to_tablesample(query, title=title) result.values[\\\"index\\\"]\",\n \"optional Maximum number of distinct elements for vColumns 1 and\",\n \"the vColumn. \\\"\\\"\\\" check_types( [ ( \\\"func\\\", func, [ \\\"abs\\\",\",\n \"h will be computed if the parameter is empty or\",\n \"meaning global outlier). \\\"\\\"\\\" if isinstance(method, str): method = method.lower()\",\n \"len(self.parent[elem].transformations) > max_floor: max_floor = len(self.parent[elem].transformations) max_floor -= len(self.transformations) for\",\n \"first_elem, second_elem = breaks[idx], breaks[idx + 1] if right: op1,\",\n \"tablesample An object containing the result. For more information, see\",\n \"vColumn. You can write the following list: [\\\"Fouad\\\", \\\"Badr\\\"] Returns\",\n \"/ date-like vColumns.\\\" ) assert len(breaks) >= 2, ParameterError( \\\"Length\",\n \"\\\"\\\"\\\" check_types( [ (\\\"method\\\", method, [str]), (\\\"of\\\", of, [str]), (\\\"max_cardinality\\\",\",\n \"vDataFrame.aggregate : Computes the vDataFrame input aggregations. \\\"\\\"\\\" return self.aggregate([\\\"max\\\"]).values[self.alias][0]\",\n \"functionality for conducting # data science projects on data stored\",\n \"= executeSQL( query=query, title=\\\"Computing the quantiles of {}.\\\".format(self.alias), method=\\\"fetchrow\\\", )\",\n \"aggregation. \\\"\\\"\\\" check_types( [ (\\\"by\\\", by, [str]), (\\\"kernel\\\", kernel, [\\\"gaussian\\\",\",\n \"import Line2D colors = gen_colors() if not xlim: xmin =\",\n \"max(2.0 * (vColumn_075 - vColumn_025) / (count) ** (1.0 /\",\n \"all_new_features = [] prefix = ( self.alias.replace('\\\"', \\\"\\\") + prefix_sep.replace('\\\"',\",\n \"+ 1 or not (labels), ParameterError( \\\"Length of parameter breaks\",\n \"use to convert the vColumn. If this parameter is equal\",\n \"2\\\". copy_name: str, optional If not empty, a copy will\",\n \"the different aggregation. aad : average absolute deviation approx_unique :\",\n \"Encodes the vColumn using a bijection from the different categories\",\n \"when 'ts' is lesser than November 1993 the 3rd. end_date:\",\n \"else: lp, rp = \\\"\\\", \\\"\\\" for category in cat:\",\n \"* (vColumn_075 - vColumn_025) / (count) ** (1.0 / 3.0),\",\n \"aims to do all of the above. The idea is\",\n \"\\\"topk\\\": assert k >= 2, ParameterError( \\\"Parameter 'k' must be\",\n \"> 0.000001: h = round(h, 6) if self.category() == \\\"int\\\":\",\n \"See Also -------- vDataFrame.isin : Looks if some specific records\",\n \"def nunique(self, approx: bool = True): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the\",\n \"is used for testing purpose. Returns ------- vDataFrame self.parent See\",\n \"vDataFrame.\\\".format( self.alias, name ) ) return self.parent # ---# def\",\n \"optional Numerical vColumn to use when the parameter method is\",\n \"bfill : Back Propagation of the next element (Constant Interpolation).\",\n \"Global Outliers. \\\"\\\"\\\" if isinstance(by, str): by = [by] check_types(\",\n \"\\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using 'product'. Returns ------- float\",\n \": q quantile (ex: 50% for the median) prod :\",\n \"--------------------------------------------------------------------------- Aggregates the vColumn using 'median'. Parameters ---------- approx: bool,\",\n \"(\\\"area\\\", area, [bool]), (\\\"step\\\", step, [bool]), ] ) self.parent.are_namecols_in(ts) ts\",\n \"max_cardinality: Union[int, tuple] = (6, 6), h: Union[int, float, tuple]\",\n \"tuple = (0.25, 0.75), start_date: Union[str, datetime.datetime, datetime.date] = \\\"\\\",\",\n \"--------------------------------------------------------------------------- Slices and transforms the vColumn using a time series\",\n \"] if method != \\\"robust_zscore\\\": max_floor = 0 for elem\",\n \"= 10): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns the n largest vColumn elements.\",\n \"self.ctype(), self.category())] self.transformations += [(func, ctype, category)] self.parent.__update_catalog__(erase=True, columns=[self.alias]) self.parent.__add_to_history__(\",\n \"of the bar. If empty, an optimized h will be\",\n \"to name the new categories. If empty, names will be\",\n \"): \\\"\\\"\\\" --------------------------------------------------------------------------- Draws the pie chart of the vColumn\",\n \"!= None ] ), ) executeSQL( \\\"SELECT {}, {} FROM\",\n \"vColumn 'of'. max : Maximum of the vColumn 'of'. sum\",\n \"element (Constant Interpolation). mean : Average. median : median. mode\",\n \"plot of the vColumn. Parameters ---------- by: str, optional vColumn\",\n \"of pie chart. auto : Regular pie chart. donut :\",\n \"total = int(total) conj = \\\"s were \\\" if total\",\n \"def bar( self, method: str = \\\"density\\\", of: str =\",\n \"nullifzero = 0 avg, stddev = self.aggregate([\\\"avg\\\", \\\"std\\\"]).values[self.alias] if stddev\",\n \"* FROM {}) {}\\\".format( self.parent.__genSQL__(), query ) query_result = executeSQL(\",\n \"self.alias, self.alias, p_1_alpha, ) mean_alpha, mean_1_alpha = [ item[0] for\",\n \"using as lower bound quantile(alpha) and as upper bound quantile(1-alpha)\",\n \"\\\"DECODE({}, {}, NULL)\\\".format( by[0], \\\", \\\".join( [ \\\"{}, {}\\\".format( \\\"'{}'\\\".format(str(elem[0]).replace(\\\"'\\\",\",\n \"an optimised interval will be computed. nbins: int, optional Number\",\n \"{}({}) OVER (PARTITION BY {}))\\\".format( \\\"{}\\\", fun, \\\"{}\\\", \\\", \\\".join(by)\",\n \"(standard error of mean). Returns ------- float sem See Also\",\n \"int, unit: str = \\\"second\\\", start: bool = True): \\\"\\\"\\\"\",\n \"[ ( \\\"{}::{}\\\".format(\\\"{}\\\", dtype), dtype, get_category_from_vertica_type(ctype=dtype), ) ] self.parent.__add_to_history__( \\\"[AsType]:\",\n \"(Z-Score), if the absolute value of the record is greater\",\n \"self, approx: bool = True, ): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the\",\n \"end_date: Union[str, datetime.datetime, datetime.date] = \\\"\\\", plot_median: bool = False,\",\n \"func 'x -> {}' to '{}'\\\".format( e, func.replace(\\\"{}\\\", \\\"x\\\"), self.alias.replace('\\\"',\",\n \") values = { \\\"index\\\": [item[0] for item in result],\",\n \") ) name = ( name.replace(\\\" \\\", \\\"_\\\") .replace(\\\"/\\\", \\\"_\\\")\",\n \"filter the data when 'ts' is lesser than November 1993\",\n \"get_category_from_vertica_type(ctype=dtype), ) ] self.parent.__add_to_history__( \\\"[AsType]: The vColumn {} was converted\",\n \"{0} || '', COUNT(*) FROM vdf_table GROUP BY {0} ORDER\",\n \"several processes with its abstractions. Parameters ---------- alias: str vColumn\",\n \"+ total self.catalog[\\\"percent\\\"] = ( 100 * (int(sauv[\\\"count\\\"]) + total)\",\n \"} for elem in catalog: self.catalog[elem] = catalog[elem] # ---#\",\n \"was successfully done.\\\") return self.parent # ---# def median( self,\",\n \"= round(h, 6) if self.category() == \\\"int\\\": h = int(max(math.floor(h),\",\n \"normalize.\\\".format( by[0] ), method=\\\"fetchall\\\", ) cmin = \\\"DECODE({}, {}, NULL)\\\".format(\",\n \"): \\\"\\\"\\\" --------------------------------------------------------------------------- Draws the spider plot of the input\",\n \"the data. bandwidth: float, optional The bandwidth of the kernel.\",\n \"can be 'minute' 'hour'... start: bool, optional If set to\",\n \"{} WHERE {} IS NOT NULL) VERTICAPY_SUBTABLE {}\\\".format( self.alias, self.alias,\",\n \"# ---# def hist( self, method: str = \\\"density\\\", of:\",\n \"---# def label_encode(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Encodes the vColumn using a\",\n \"(\\\"h\\\", h, [int, float]), (\\\"pie_type\\\", pie_type, [\\\"auto\\\", \\\"donut\\\", \\\"rose\\\"]), ]\",\n \"'cat_stats'\\\" ) distinct_count, is_numeric, is_date = ( self.nunique(), self.isnum(), self.isdate(),\",\n \"else: op1, op2, close_l, close_r = \\\"<=\\\", \\\"<\\\", \\\"[\\\", \\\"[\\\"\",\n \"( \\\"PARTITION BY {}\\\".format( \\\", \\\".join([quote_ident(column) for column in by])\",\n \"input vColumns based on an aggregation. \\\"\\\"\\\" check_types( [ (\\\"by\\\",\",\n \"'response' can not be empty in case of discretization using\",\n \"'{}'::timestamp, {}) AS {} FROM {}) VERTICAPY_OPTIMAL_H_TABLE\\\".format( min_date, self.alias, self.alias,\",\n \"logarithm log10 : base 10 logarithm mod : remainder of\",\n \"elif fun == \\\"MEDIAN\\\": val = self.median() new_column = \\\"COALESCE({},\",\n \"(upper != None), ParameterError( \\\"At least 'lower' or 'upper' must\",\n \"= len(result) trans = \\\"(CASE \\\" for i in range(1,\",\n \"in order_by] for elem in all_partition: if len(self.parent[elem].transformations) > max_floor:\",\n \"\\\"varchar\\\", \\\"text\\\", ) else: trans = (\\\"FLOOR({}) || ''\\\", \\\"varchar\\\",\",\n \"self.parent See Also -------- vDataFrame.case_when : Creates a new feature\",\n \"title=\\\"Computing the optimized histogram nbins using Random Forest.\\\", method=\\\"fetchall\\\", )\",\n \"numerical. \\\"\\\"\\\" return self.ctype().lower() in (\\\"bool\\\", \\\"boolean\\\") # ---# def\",\n \"str): val = val.replace(\\\"'\\\", \\\"''\\\") if val != None: new_column\",\n \"} return tablesample(values) # ---# def value_counts(self, k: int =\",\n \"# ---# def normalize( self, method: str = \\\"zscore\\\", by:\",\n \"argument. Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].apply :\",\n \"pre_comp = self.parent.__get_catalog_value__(self.alias, \\\"numh\\\") if pre_comp != \\\"VERTICAPY_NOT_PRECOMPUTED\\\": return pre_comp\",\n \"parent, alias, [elem for elem in transformations], ) self.catalog =\",\n \"= 0): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns a part of the vColumn\",\n \"BY {0} ORDER BY COUNT(*) DESC LIMIT {1})\\\"\\\"\\\".format( self.alias, max_cardinality\",\n \"creating a copy with the specified name. \\\\u26A0 Warning :\",\n \"[int, float])]) assert x != 0, ValueError(\\\"Division by 0 is\",\n \"= 6, new_category: str = \\\"Others\\\", RFmodel_params: dict = {},\",\n \"abstractions. Parameters ---------- alias: str vColumn alias. transformations: list, optional\",\n \") query = \\\"SELECT {}, ord, non_events, events, non_events /\",\n \"(\\\"None\\\", None)) else \\\" WHERE {} = '{}'\\\".format( bin_spatial_to_str(self.category(), self.alias),\",\n \"dependent variable. Parameters ---------- y: str Response vColumn. nbins: int,\",\n \"Slices the vColumn. \\\"\\\"\\\" check_types([(\\\"pat\\\", pat, [str])]) return self.apply( func=\\\"REGEXP_SUBSTR({},\",\n \"is missing. Returns ------- vDataFrame self.parent See Also -------- vDataFrame.filter:\",\n \"user defined Encoding. vDataFrame[].discretize : Discretizes the vColumn. vDataFrame[].label_encode :\",\n \"(\\\"include_lowest\\\", include_lowest, [bool]), (\\\"right\\\", right, [bool]), ] ) assert self.isnum()\",\n \"[self.alias]) .transpose() .values[self.alias] ) self.parent.filter( \\\"({} BETWEEN {} AND {})\\\".format(self.alias,\",\n \"'of' (ex: 50% to get the median). It can also\",\n \"loc=\\\"center left\\\", bbox_to_anchor=[1, 0.5], ) ax.set_xlabel(self.alias) return ax kernel =\",\n \"== \\\"0ifnull\\\": new_column = \\\"DECODE({}, NULL, 0, 1)\\\" elif method\",\n \"float])]) return self.apply(func=\\\"SUBSTR({}, {}, {})\\\".format(\\\"{}\\\", start, step)) # ---# def\",\n \"dropna(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Filters the vDataFrame where the vColumn is\",\n \"elem in distinct ] ), bin_spatial_to_str(self.category()), new_category.replace(\\\"'\\\", \\\"''\\\"), ), \\\"varchar\\\",\",\n \"steps different than 1.\\\" ) index_stop = index.stop index_start =\",\n \"see: https://geopandas.readthedocs.io/en/latest/docs/reference/api/ geopandas.GeoDataFrame.plot.html Returns ------- ax Matplotlib axes object \\\"\\\"\\\"\",\n \"the vColumn. One vDataFrame can have multiple children vColumns whereas\",\n \"'smart'. A RF Regressor will be trained if the response\",\n \"method=\\\"fetchall\\\", ) cmin = \\\"DECODE({}, {}, NULL)\\\".format( by[0], \\\", \\\".join(\",\n \"vColumn can only have one parent. catalog: dict, optional Catalog\",\n \"[str]), (\\\"of\\\", of, [str]), (\\\"max_cardinality\\\", max_cardinality, [int, float]), (\\\"nbins\\\", nbins,\",\n \"vDataFrame.topk : Returns the vColumn most occurent elements. \\\"\\\"\\\" if\",\n \"key corresponds to an aggregation. vColumns will memorize the already\",\n \"ord, {}::int AS {} FROM {}\\\".format( trans, self.alias, self.alias, y,\",\n \"\\\"''\\\") if val != None: new_column = \\\"COALESCE({}, '{}')\\\".format(\\\"{}\\\", val)\",\n \"self.parent[y].distinct() trans = self.discretize( method=\\\"same_width\\\" if self.isnum() else \\\"topk\\\", nbins=nbins,\",\n \"**style_kwds, ): \\\"\\\"\\\" --------------------------------------------------------------------------- Draws the box plot of the\",\n \"\\\"\\\"\\\" --------------------------------------------------------------------------- Slices the vColumn. The vColumn will be transformed.\",\n \"False if check: self.parent.are_namecols_in(column) column = self.parent.format_colnames(column) columns += [column]\",\n \"of the vColumns categories. Returns ------- vDataFrame self.parent See Also\",\n \"See Also -------- vDataFrame[].apply : Applies a function to the\",\n \"= ( \\\"(CASE WHEN {} IN ({}) THEN {} ||\",\n \") method = method.lower() if self.isnum() and method == \\\"smart\\\":\",\n \"\\\\/_/ \\\\/_/ \\\\/_/ # # # ---# class vColumn(str_sql): \\\"\\\"\\\"\",\n \"{}{}) || ']'\\\".format( \\\"{}\\\", h, h, \\\"{}\\\", h, h, h,\",\n \"n == 0: nullifzero = 0 cmin, cmax = self.aggregate([\\\"min\\\",\",\n \"True, the approximate quantile is returned. By setting this parameter\",\n \"name ) ) return self.parent # ---# def aggregate(self, func:\",\n \"[ \\\"unique\\\", \\\"count\\\", \\\"mean\\\", \\\"std\\\", \\\"min\\\", \\\"approx_25%\\\", \\\"approx_50%\\\", \\\"approx_75%\\\", \\\"max\\\",\",\n \"-------- vDataFrame.apply : Applies functions to the input vColumns. vDataFrame.applymap\",\n \"picked or computed) h: float, optional Interval width of the\",\n \"Returns ------- float quantile (or approximate quantile). See Also --------\",\n \"{} partitioned by {}.\\\".format( numcol, self.alias ) values = to_tablesample(query,\",\n \"(PARTITION BY {})\\\".format(response, \\\"{}\\\"), \\\"int\\\", \\\"float\\\") ] self.parent.__update_catalog__(erase=True, columns=[self.alias]) self.parent.__add_to_history__(\",\n \"not be converted to {}\\\".format( e, self.alias, dtype ) )\",\n \"date like). The vColumn will be transformed. Parameters ---------- field:\",\n \"\\\"agg\\\" not in kwargs: query = \\\"SELECT {} AS {}\",\n \"category, self.alias, self.parent.shape()[0], numcol, cast, ) tmp_query += ( \\\"\",\n \"in elem: self.catalog[elem] = sauv[elem] elif elem == None: self.catalog[elem]\",\n \"computed. ax: Matplotlib axes object, optional The axes to plot\",\n \"\\\"Computing WOE & IV of {} (response = {}).\\\".format(self.alias, y)\",\n \"self.parent See Also -------- vDataFrame[].fill_outliers : Fills the vColumn outliers\",\n \"is only valid if the vColumns are numerical. Optimized h\",\n \"int = -1, dropna: bool = True): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns\",\n \"optional Interval width if the vColumn is numerical or of\",\n \"\\\"\\\", cmax, cmin, ), \\\"float\\\", \\\"float\\\", ) ] if method\",\n \"1\\\".format( self.alias, cast, self.parent.__genSQL__(), self.parent.__get_last_order_by__(), index, ) return executeSQL( query=query,\",\n \"float = 2): \\\"\\\"\\\" --------------------------------------------------------------------------- Applies a default function to\",\n \"operation pow : number raised to the power of another\",\n \"vColumns. vDataFrame.applymap : Applies a function to all the vColumns.\",\n \"\\\"\\\"\\\" check_types( [ (\\\"ts\\\", ts, [str]), (\\\"q\\\", q, [tuple]), (\",\n \"# ---# def ctype(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns the vColumn DB\",\n \"sine atan : trigonometric inverse tangent cbrt : cube root\",\n \"max( float(vColumn_max - vColumn_min) / int(math.floor(math.log(count, 2) + 2)), 1e-99,\",\n \"datetime.datetime, datetime.date] = \\\"\\\", plot_median: bool = False, ax=None, **style_kwds,\",\n \") # ---# def plot( self, ts: str, by: str\",\n \"q: tuple = (0.25, 0.75), start_date: Union[str, datetime.datetime, datetime.date] =\",\n \"the categorical vColumns. bfill : Back Propagation of the next\",\n \"): \\\"\\\"\\\" --------------------------------------------------------------------------- Draws the histogram of the vColumn based\",\n \"Computes bins with the same number of elements. same_width :\",\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__(\",\n \"of the distribution. mean : Average of the vColumn 'of'.\",\n \"computed. h: float, optional Interval width of the bar. If\",\n \"VERTICAPY_SUBTABLE ORDER BY _verticapy_cnt_ ASC LIMIT 1\\\".format( self.alias, self.alias, self.parent.__genSQL__(),\",\n \"ord\\\".format( self.alias, query, ) title = \\\"Computing WOE & IV\",\n \"- vColumn_min) / int(math.floor(math.log(count, 2) + 2)), 1e-99, ) fd\",\n \"__ # /\\\\ \\\\ / / /\\\\ ___\\\\ /\\\\ __\",\n \"amount of expressions. The expression generated will look like: even:\",\n \"elif h > 0.000001: h = round(h, 6) if self.category()\",\n \"represent a number. Returns ------- vDataFrame self.parent See Also --------\",\n \"following: (function, type, category) parent: vDataFrame, optional Parent of the\",\n \"increase the time of the learning and scoring phases. xlim:\",\n \"be picked or computed) ax: Matplotlib axes object, optional The\",\n \"self.apply(func=\\\"ABS({})\\\") # ---# def add(self, x: float): \\\"\\\"\\\" --------------------------------------------------------------------------- Adds\",\n \"bool, optional If set to True, the approximate median is\",\n \"+= [sum(result[\\\"events\\\"])] result.values[\\\"pt_non_events\\\"] += [\\\"\\\"] result.values[\\\"pt_events\\\"] += [\\\"\\\"] result.values[\\\"woe\\\"] +=\",\n \") ) else: raise TypeError(\\\"The vColumn must be numerical for\",\n \"x limits of the current axes. ax: Matplotlib axes object,\",\n \"the vColumn will be considered as categorical. numcol: str, optional\",\n \"max_cardinality + 1) and (method != \\\"numerical\\\")) or not (is_numeric)\",\n \"if (k < 1) else \\\"LIMIT {}\\\".format(k) dropna = \\\"\",\n \"method=\\\"fetchall\\\", ) values = { \\\"index\\\": [item[0] for item in\",\n \"vDataFrame.outliers : Computes the vDataFrame Global Outliers. \\\"\\\"\\\" if isinstance(by,\",\n \"empty\\\\nIf you want to normalize by grouping by elements, please\",\n \"* 100)]).values[self.alias][ 0 ] # ---# def range_plot( self, ts:\",\n \"{} IS NOT NULL LIMIT 0\\\".format( func.replace(\\\"{}\\\", self.alias), self.parent.__genSQL__(), self.alias,\",\n \"elif elem == None: self.catalog[elem] = None elif method ==\",\n \"to True, the record will be sliced using the floor\",\n \"title=\\\"Computing the top{} categories of {}.\\\".format( k if k >\",\n \"std, MIN({3}{4}) AS min, APPROXIMATE_PERCENTILE ({3}{4} USING PARAMETERS percentile =\",\n \"xmax = xlim custom_lines = [] columns = self.parent[by].distinct() for\",\n \"] elif method == \\\"robust_zscore\\\": if n > 0: warning_message\",\n \"), ) stddev = \\\"DECODE({}, {}, NULL)\\\".format( by[0], \\\", \\\".join(\",\n \"vColumn cardinality (or approximate cardinality). See Also -------- vDataFrame.aggregate :\",\n \"to avoid the creation of correlated features. use_numbers_as_suffix: bool, optional\",\n \"functions to the input vColumns. vDataFrame.applymap : Applies a function\",\n \"\\\"int\\\", \\\"bool\\\" else: category, ctype = self.category(), self.ctype() copy_trans =\",\n \"---# def astype(self, dtype: str): \\\"\\\"\\\" --------------------------------------------------------------------------- Converts the vColumn\",\n \"return self.apply(func=\\\"{} + ({})\\\".format(\\\"{}\\\", x)) # ---# def add_copy(self, name:\",\n \"be created using the input Name. Returns ------- vDataFrame self.parent\",\n \"the vDataFrame input aggregations. \\\"\\\"\\\" check_types([(\\\"approx\\\", approx, [bool])]) if approx:\",\n \"vColumn using 'var' (Variance). Returns ------- float var See Also\",\n \"\\\"SELECT {} FROM (SELECT {}, ROW_NUMBER() OVER (ORDER BY {})\",\n \"i + 1] ... END odd : CASE ... WHEN\",\n \"optimized h will be computed. ax: Matplotlib axes object, optional\",\n \"DATEDIFF('second', '{}'::timestamp, {}) AS {} FROM {}) VERTICAPY_OPTIMAL_H_TABLE\\\".format( min_date, self.alias,\",\n \"\\\"approx_50%\\\", \\\"approx_75%\\\", \\\"max\\\", ] if method != \\\"cat_stats\\\": values =\",\n \"the input list. Parameters ---------- breaks: list List of values\",\n \"floor_end = -1 if (self.category() == \\\"int\\\") else \\\"\\\" if\",\n \"vDataFrame[].bar : Draws the Bar Chart of vColumn based on\",\n \"BY {}) OVER () FROM {} LIMIT 1\\\".format( alpha, self.alias,\",\n \"0 when the vColumn is null, 1 otherwise. expr: str,\",\n \"elem in sauv: if \\\"top\\\" in elem: if \\\"percent\\\" in\",\n \"nb != 0, Exception( \\\"Not enough values to compute the\",\n \"Optimized h will be computed if the parameter is empty\",\n \"was applied to the vColumn {}\\\\n{} feature{}created: {}\\\".format( self.alias, len(all_new_features),\",\n \"value, [str])]) return self.apply( func=\\\"REGEXP_REPLACE({}, '{}', '{}')\\\".format( \\\"{}\\\", to_replace.replace(\\\"'\\\", \\\"''\\\"),\",\n \"to fill the vColumn outliers. mean : Replaces the upper\",\n \"( self.nunique(), self.isnum(), self.isdate(), ) if (is_date) and not (method\",\n \"with the One-Hot Encoding algorithm. Parameters ---------- prefix: str, optional\",\n \"vColumn {}.\\\".format(self.alias), method=\\\"fetchfirstelem\\\", ) self.parent.__update_catalog__( {\\\"index\\\": [\\\"store_usage\\\"], self.alias: [store_usage]} )\",\n \"\\\" WHERE {} IS NOT NULL \\\".format(self.alias) if (dropna) else\",\n \"performance. The catalog will be updated when the parent vDataFrame\",\n \"use to compute the aggregation. max_cardinality: int, optional Maximum number\",\n \"cycle, uses a ‘pipeline’ mechanism to sequentialize # data transformation\",\n \"Also -------- vDataFrame.aggregate : Computes the vDataFrame input aggregations. \\\"\\\"\\\"\",\n \"self.catalog[elem] = (sauv[elem] - sauv[\\\"min\\\"]) / ( sauv[\\\"max\\\"] - sauv[\\\"min\\\"]\",\n \"distinct ] ), bin_spatial_to_str(self.category()), new_category.replace(\\\"'\\\", \\\"''\\\"), ), \\\"varchar\\\", \\\"text\\\", )\",\n \"{}.\\\".format( k if k > 0 else \\\"\\\", self.alias ),\",\n \"{0} ORDER BY COUNT(*)\\\" \\\" DESC OFFSET {1}) VERTICAPY_SUBTABLE) ORDER\",\n \"writing, software # distributed under the License is distributed on\",\n \"expr = \\\"CASE WHEN \\\" + \\\" WHEN \\\".join(conditions) +\",\n \"using the method 'same_freq'\\\" ) count = self.count() nb =\",\n \"using the mean encoding of a response. \\\"\\\"\\\" import verticapy.stats\",\n \"& IV of {} (response = {}).\\\".format(self.alias, y) result =\",\n \"be date like (date, datetime, timestamp...) or numerical. by: str,\",\n \"in each of the vColumn records. vDataFrame[].str_count : Computes the\",\n \"Drops the first dummy to avoid the creation of correlated\",\n \"elem[1] if elem[1] != None else \\\"NULL\\\", ) for elem\",\n \"aggregations. \\\"\\\"\\\" return self.aggregate([\\\"skewness\\\"]).values[self.alias][0] skew = skewness # ---# def\",\n \"self.parent.__genSQL__(), self.alias, ), \\\"apply_test_feature\\\", ) except: ctype = get_data_types( \\\"SELECT\",\n \"\\\"\\\\t{} => {}\\\".format(distinct_elements[k], k) expr = \\\", \\\".join(expr) + \\\",\",\n \"\\\".join( [\\\"{}, {}\\\".format(elem[0], elem[1]) for elem in result] ), )\",\n \"title=title).values elif ( ((distinct_count < max_cardinality + 1) and (method\",\n \"result[i], result[i - 1], result[i] ) trans += \\\" ELSE\",\n \"the partition. order_by: list, optional List of the vColumns to\",\n \"--------------------------------------------------------------------------- Encodes the vColumn with the One-Hot Encoding algorithm. Parameters\",\n \"where, self.alias, n ), title=\\\"Computing the mode.\\\", method=\\\"fetchall\\\", ) top\",\n \"size. unit: str, optional Slice size unit. For example, it\",\n \"self.alias), self.alias, self.parent.__genSQL__(), self.parent.__get_last_order_by__(), limit, offset, ), title=title, ) tail.count\",\n \"vDataFrame[].get_dummies : Encodes the vColumn with One-Hot Encoding. \\\"\\\"\\\" check_types([(\\\"response\\\",\",\n \"of the input vColumns. \\\"\\\"\\\" if isinstance(cat_priority, str) or not\",\n \"/ _ __|_. _ _ |_) # \\\\/ (/_| |\",\n \"n: int): \\\"\\\"\\\" --------------------------------------------------------------------------- Rounds the vColumn by keeping only\",\n \"self.parent # ---# def fill_outliers( self, method: str = \\\"winsorize\\\",\",\n \"width. \\\"\\\"\\\" check_types( [(\\\"method\\\", method, [\\\"sturges\\\", \\\"freedman_diaconis\\\", \\\"fd\\\", \\\"auto\\\"])] )\",\n \"MILLISECONDS / MINUTE / MONTH / QUARTER / SECOND /\",\n \"True if the vColumn category is date. See Also --------\",\n \"method 'topk'\\\" ) distinct = self.topk(k).values[\\\"index\\\"] trans = ( \\\"(CASE\",\n \"and the min sem : standard error of the mean\",\n \") query_result = executeSQL( query=query, title=\\\"Computing the distinct categories of\",\n \"op2, close_l, close_r = \\\"<=\\\", \\\"<\\\", \\\"[\\\", \\\"[\\\" if idx\",\n \"* i + 1] ... ELSE argv[n] END Returns -------\",\n \"lesser than quantile(alpha) or greater than quantile(1-alpha) will be filled.\",\n \"check_types( [ ( \\\"method\\\", method, [ \\\"auto\\\", \\\"mode\\\", \\\"0ifnull\\\", \\\"mean\\\",\",\n \"# ---# def pie( self, method: str = \\\"density\\\", of:\",\n \"return_enum_trans: bool, optional Returns the transformation instead of the vDataFrame\",\n \"self.alias, n ) title = \\\"Reads {} {} smallest elements.\\\".format(n,\",\n \"bool = False ): \\\"\\\"\\\" --------------------------------------------------------------------------- Normalizes the input vColumns\",\n \"FROM {}{} LIMIT {} OFFSET {}\\\".format( bin_spatial_to_str(self.category(), self.alias), self.alias, self.parent.__genSQL__(),\",\n \"named {} was added to the vDataFrame.\\\".format( self.alias, name )\",\n \"{}, '{}', '{}')\\\".format( \\\"{}\\\", length, unit.upper(), start_or_end ) ) #\",\n \"\\\"\\\"\\\" check_types([(\\\"x\\\", x, [int, float])]) if self.isdate(): return self.apply(func=\\\"TIMESTAMPADD(SECOND, -({}),\",\n \"self.alias, table ) result = executeSQL( query, title=\\\"Different aggregations to\",\n \"of the different categories to consider when drawing the box\",\n \"avg, \\\"NULLIFZERO\\\" if (nullifzero) else \\\"\\\", stddev ) else: final_transformation\",\n \"non_events, SUM({}) AS events FROM ({}) x GROUP BY 1\\\".format(\",\n \"== \\\"mode\\\") and (val == None): val = self.mode(dropna=True) if\",\n \"non_events, events, non_events / NULLIFZERO(SUM(non_events) OVER ()) AS pt_non_events, events\",\n \"= [] model = KernelDensity( name, bandwidth=bandwidth, kernel=kernel, nbins=nbins, xlim=xlim_tmp,\",\n \"= True): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns the k most occurent elements\",\n \"part of the vColumn (delimited by an offset and a\",\n \"dropna: bool, optional If set to True, NULL values will\",\n \"head(self, limit: int = 5): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns the head\",\n \"# ---# def apply(self, func: str, copy_name: str = \\\"\\\"):\",\n \"optional Upper bound. Returns ------- vDataFrame self.parent See Also --------\",\n \"columns += [column] if not (\\\"cmap\\\" in kwargs): from verticapy.plot\",\n \"= \\\"Can not normalize {} using the MIN and the\",\n \"trans else: self.transformations += [trans] sauv = {} for elem\",\n \"aggregations. \\\"\\\"\\\" check_types([(\\\"x\\\", x, [int, float], (\\\"approx\\\", approx, [bool]))]) prefix\",\n \"Parameters ---------- start: int Start of the slicing. step: int\",\n \"self.aggregate([\\\"max\\\"]).values[self.alias][0] # ---# def mean_encode(self, response: str): \\\"\\\"\\\" --------------------------------------------------------------------------- Encodes\",\n \"self.alias, n ), title=\\\"Computing the mode.\\\", method=\\\"fetchall\\\", ) top =\",\n \"be 'minute' 'hour'... start: bool, optional If set to True,\",\n \"100)]).values[self.alias][ 0 ] # ---# def range_plot( self, ts: str,\",\n \"to check if Badr and Fouad are in the vColumn.\",\n \"ln : natural logarithm log : logarithm log10 : base\",\n \"!= 0, ValueError(\\\"Division by 0 is forbidden !\\\") return self.apply(func=\\\"{}\",\n \"Applies a function to the input vColumn. \\\"\\\"\\\" check_types( [\",\n \"# ______ / / # \\\\ / / / #\",\n \"to the input vColumn. Returns ------- vDataFrame self.parent See Also\",\n \"the new vDataFrame of the search. Parameters ---------- val: list\",\n \"{} was deleted from the vDataFrame.\\\".format(self.alias) ) return parent #\",\n \"OVER ()) AS pt_events FROM ({}) x\\\".format( self.alias, query, )\",\n \"the input method. \\\"\\\"\\\" check_types([(\\\"lower\\\", lower, [float, int]), (\\\"upper\\\", upper,\",\n \"str TS (Time Series) vColumn to use to order the\",\n \"element{}filled.\\\".format(total, conj)) self.parent.__add_to_history__( \\\"[Fillna]: {} {} missing value{} filled.\\\".format( total,\",\n \"[self.max()] elif method == \\\"topk\\\": assert k >= 2, ParameterError(\",\n \"with Label Encoding. vDataFrame[].get_dummies : Encodes the vColumn with One-Hot\",\n \"\\\"\\\"\\\" return self.apply(func=\\\"ABS({})\\\") # ---# def add(self, x: float): \\\"\\\"\\\"\",\n \"0.5) AS 'approx_50%', APPROXIMATE_PERCENTILE ({3}{4} USING PARAMETERS percentile = 0.75)\",\n \"ax=ax, **style_kwds) # ---# def iloc(self, limit: int = 5,\",\n \"min(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using 'min' (Minimum). Returns\",\n \"self.parent.shape()[0] limit = index_stop - index_start if limit <= 0:\",\n \"RandomForestRegressor(tmp_model_name) else: model = RandomForestClassifier(tmp_model_name) model.set_params({\\\"n_estimators\\\": 20, \\\"max_depth\\\": 8, \\\"nbins\\\":\",\n \"vDataFrame self.parent See Also -------- vDataFrame[].date_part : Extracts a specific\",\n \"parent: vDataFrame, optional Parent of the vColumn. One vDataFrame can\",\n \"hist( self, method: str = \\\"density\\\", of: str = \\\"\\\",\",\n \"the Box Plot of the input vColumns. \\\"\\\"\\\" if isinstance(cat_priority,\",\n \"vDataFrame.aggregate : Computes the vDataFrame input aggregations. \\\"\\\"\\\" return self.aggregate([\\\"min\\\"]).values[self.alias][0]\",\n \"1993 the 3rd. plot_median: bool, optional If set to True,\",\n \"= \\\"<=\\\", \\\"[\\\" elif idx == 0: op1, close_l =\",\n \"+ 1] ... ELSE argv[n] END Returns ------- vDataFrame self.parent\",\n \"vColumn based on an aggregation. \\\"\\\"\\\" check_types( [ (\\\"method\\\", method,\",\n \"as categorical (No h will be picked or computed) ax:\",\n \"used for the discretization (must be > 1) k: int,\",\n \"to convert to use to convert the vColumn. If this\",\n \"using previously the method on the vColumn \\\" \\\"or simply\",\n \"Encodes the vColumn with Label Encoding. vDataFrame[].mean_encode : Encodes the\",\n \"= breaks[idx], breaks[idx + 1] if right: op1, op2, close_l,\",\n \"10 logarithm mod : remainder of a division operation pow\",\n \"MICROSECONDS / MILLENNIUM / MILLISECONDS / MINUTE / MONTH /\",\n \"] ), bin_spatial_to_str(self.category()), new_category.replace(\\\"'\\\", \\\"''\\\"), ), \\\"varchar\\\", \\\"text\\\", ) elif\",\n \"== \\\"MEDIAN\\\": fun = \\\"APPROXIMATE_MEDIAN\\\" query = \\\"SELECT {}, {}({})\",\n \"result sturges = max( float(vColumn_max - vColumn_min) / int(math.floor(math.log(count, 2)\",\n \"/ NULLIFZERO(SUM(non_events) OVER ()) AS pt_non_events, events / NULLIFZERO(SUM(events) OVER\",\n \"[dict]), (\\\"return_enum_trans\\\", return_enum_trans, [bool]), (\\\"h\\\", h, [int, float]), (\\\"response\\\", response,\",\n \"== \\\"date\\\" # ---# def isin(self, val: list, *args): \\\"\\\"\\\"\",\n \"or 'upper' must have a numerical value\\\" ) lower_when =\",\n \"True, the record will be sliced using the floor of\",\n \"if n == 0: nullifzero = 0 avg, stddev =\",\n \"Returns the vDataFrame memory usage. \\\"\\\"\\\" import sys total =\",\n \"For more information, see utilities.tablesample. See Also -------- vDataFrame.aggregate :\",\n \"title=\\\"Computing the different categories to normalize.\\\", method=\\\"fetchall\\\", ) for i\",\n \"( \\\"MAX({}) OVER (PARTITION BY {})\\\".format( self.alias, \\\", \\\".join(by) ),\",\n \"to use to order the data. The vColumn type must\",\n \"only if the parameter 'by' is empty\\\\nIf you want to\",\n \"values).\\\\nNothing was filled.\\\".format( self.alias ) warnings.warn(warning_message, Warning) return self.parent if\",\n \"self.parent.isin(val) # ---# def isnum(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns True if\",\n \"query = \\\"SELECT {} FROM (SELECT {} AS {}, {}\",\n \"Returns ------- ax Matplotlib axes object See Also -------- vDataFrame.plot\",\n \"the box plot. The other categories will be filtered. ax:\",\n \"float quantile (or approximate quantile). See Also -------- vDataFrame.aggregate :\",\n \"self.parent See Also -------- vDataFrame[].slice : Slices the vColumn using\",\n \"else \\\"mode\\\" total = self.count() if (method == \\\"mode\\\") and\",\n \"\\\"s were \\\" if len(all_new_features) > 1 else \\\" was\",\n \"not (schema): schema = \\\"public\\\" tmp_view_name = gen_tmp_name(schema=schema, name=\\\"view\\\") tmp_model_name\",\n \") else: return getattr(self, index) # ---# def __len__(self): return\",\n \"method in (\\\"ffill\\\", \\\"pad\\\", \\\"bfill\\\", \\\"backfill\\\"): assert order_by, ParameterError( \\\"If\",\n \"Also -------- vDataFrame.add_copy : Creates a copy of the vColumn.\",\n \"title=\\\"Computing the distinct categories of {}.\\\".format(self.alias), method=\\\"fetchall\\\", ) return [item\",\n \"next element (Constant Interpolation). ffill : Propagation of the first\",\n \"[\\\"numh\\\"], self.alias: [best_h]}) if self.category() == \\\"int\\\": best_h = max(math.floor(best_h),\",\n \"5): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns the head of the vColumn. Parameters\",\n \"if (nullifzero) else \\\"\\\", cmax, cmin, ) else: final_transformation =\",\n \"self.alias, dtype ) ) # ---# def avg(self): \\\"\\\"\\\" ---------------------------------------------------------------------------\",\n \"Cardinality threshold to use to determine if the vColumn will\",\n \") else: avg, stddev = ( \\\"AVG({}) OVER (PARTITION BY\",\n \"-------- vDataFrame[].isbool : Returns True if the vColumn is boolean.\",\n \"moving # data around for processing, VerticaPy brings the logic\",\n \"# # ---# def __init__( self, alias: str, transformations: list\",\n \"= labels[idx] else: label = f\\\"{close_l}{first_elem};{second_elem}{close_r}\\\" conditions += [ f\\\"'{first_elem}'\",\n \"\\\"robust_zscore\\\": max_floor = 0 for elem in by: if len(self.parent[elem].transformations)\",\n \"(except ints and bools), a RF Classifier otherwise. Example: Write\",\n \"self.alias, self.parent.__genSQL__(), where, self.alias, n ), title=\\\"Computing the mode.\\\", method=\\\"fetchall\\\",\",\n \"Returns the n largest vColumn elements. Parameters ---------- n: int,\",\n \"vColumns will memorize the already computed aggregations to gain in\",\n \"n): name = ( '\\\"{}{}\\\"'.format(prefix, k) if (use_numbers_as_suffix) else '\\\"{}{}\\\"'.format(\",\n \"AS {} FROM {} WHERE {} IS NOT NULL GROUP\",\n \"FROM {}{} OFFSET {} LIMIT 1\\\".format( self.alias, cast, self.parent.__genSQL__(), self.parent.__get_last_order_by__(),\",\n \".transpose() .values[self.alias] ) result = [distinct_count] + result index =\",\n \"\\\".join(conditions) + \\\" END\\\" self.apply(func=expr) # ---# def ctype(self): \\\"\\\"\\\"\",\n \"h = int(max(math.floor(h), 1)) floor_end = -1 if (self.category() ==\",\n \"\\\"Not enough values to compute the Equal Frequency discretization\\\" )\",\n \"new feature by evaluating some conditions. vDataFrame[].discretize : Discretizes the\",\n \"AND {})\\\".format(self.alias, p_alpha, p_1_alpha) ) return self.parent # ---# def\",\n \"vColumns whereas one vColumn can only have one parent. catalog:\",\n \"partition. return_trans: bool, optimal If set to True, the method\",\n \"expression generated will look like: even: CASE ... WHEN vColumn\",\n \"occurent elements. \\\"\\\"\\\" if \\\"agg\\\" not in kwargs: query =\",\n \"for elem in result] elif self.isnum() and method in (\\\"same_width\\\",\",\n \"_ |_) # \\\\/ (/_| | |(_(_|| \\\\/ # /\",\n \"/ ({})\\\".format(\\\"{}\\\", x)) # ---# def drop(self, add_history: bool =\",\n \"ELSE (pt_non_events - pt_events) * ZEROIFNULL(LN(pt_non_events / NULLIFZERO(pt_events))) END AS\",\n \"a cutomized aggregation (ex: AVG(column1) + 5). ax: Matplotlib axes\",\n \"unique category. h: float, optional The interval size to convert\",\n \"GROUP BY 1\\\".format( self.alias, y, y, query, ) query =\",\n \"self.aggregate([\\\"count\\\"]).values[self.alias][0] # ---# def cut( self, breaks: list, labels: list\",\n \"tuple] = (None, None), ax=None, **style_kwds, ): \\\"\\\"\\\" --------------------------------------------------------------------------- Draws\",\n \"and upper ZScores. threshold: float, optional Uses the Gaussian distribution\",\n \"datetime.datetime, datetime.date, int, float], ), (\\\"plot_median\\\", plot_median, [bool]), ] )\",\n \"tail.name = self.alias return tail # ---# def isbool(self): \\\"\\\"\\\"\",\n \"Any optional parameter to pass to the Matplotlib functions. Returns\",\n \"Replaces the upper and lower outliers by their respective average.\",\n \"rule. Parameters ---------- val: int/float/str, optional Value to use to\",\n \"\\\"]\\\" if labels: label = labels[idx] else: label = f\\\"{close_l}{first_elem};{second_elem}{close_r}\\\"\",\n \"+= [column] if not (\\\"cmap\\\" in kwargs): from verticapy.plot import\",\n \"sublist in query_result for item in sublist] # ---# def\",\n \"warnings.warn(warning_message, Warning) return self mad, med = self.aggregate([\\\"mad\\\", \\\"approx_median\\\"]).values[self.alias] mad\",\n \"else '\\\"{}{}\\\"'.format( prefix, str(distinct_elements[k]).replace('\\\"', \\\"_\\\") ) ) assert not (self.parent.is_colname_in(name)),\",\n \"'new_name', you'll be able to solve this issue.\\\" ) self.add_copy(new_name)\",\n \"two flower brackets {}. For example to apply the function:\",\n \"--------------------------------------------------------------------------- Returns the n smallest elements in the vColumn. Parameters\",\n \"self.alias, conj, ) ) else: if verticapy.options[\\\"print_info\\\"]: print(\\\"Nothing was filled.\\\")\",\n \"return self.parent # ---# def count(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the\",\n \"\\\"sturges\\\": best_h = sturges elif method.lower() in (\\\"freedman_diaconis\\\", \\\"fd\\\"): best_h\",\n \"print_time_sql=False, ) except: avg, stddev = ( \\\"AVG({}) OVER (PARTITION\",\n \"\\\"\\\"\\\" --------------------------------------------------------------------------- Applies a default function to the vColumn. Parameters\",\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\\\")\",\n \"str, optional vColumn to use to partition the data. method:\",\n \"of the vColumn. See Also -------- vDataFrame.topk : Returns the\",\n \"LIMIT {}) VERTICAPY_SUBTABLE ORDER BY _verticapy_cnt_ ASC LIMIT 1\\\".format( self.alias,\",\n \"Returns ------- vDataFrame self.parent See Also -------- vDataFrame.add_copy : Creates\",\n \"elem in result] elif self.isnum() and method in (\\\"same_width\\\", \\\"auto\\\"):\",\n \"nbins, [float, int]), ] ) if by: self.parent.are_namecols_in(by) by =\",\n \"pre_comp != \\\"VERTICAPY_NOT_PRECOMPUTED\\\": return pre_comp store_usage = executeSQL( \\\"SELECT ZEROIFNULL(SUM(LENGTH({}::varchar)))\",\n \"response. \\\"\\\"\\\" if self.category() in [\\\"date\\\", \\\"float\\\"]: warning_message = (\",\n \") ) elif method == \\\"mean\\\": query = \\\"WITH vdf_table\",\n \"return_enum_trans, [bool]), (\\\"h\\\", h, [int, float]), (\\\"response\\\", response, [str]), (\\\"nbins\\\",\",\n \"Returns ------- ax Matplotlib axes object See Also -------- vDataFrame.bar\",\n \"you are using. Returns ------- tablesample An object containing the\",\n \"= None avg = \\\"DECODE({}, {}, NULL)\\\".format( by[0], \\\", \\\".join(\",\n \"1): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns the nth most occurent element. Parameters\",\n \"transformation must be similar to the following: (function, type, category)\",\n \"to the input type. Parameters ---------- dtype: str New type.\",\n \"The name of the merging category when using the 'topk'\",\n \": Computes the vDataFrame input aggregations. \\\"\\\"\\\" return self.aggregate([\\\"count\\\"]).values[self.alias][0] #\",\n \"[\\\"Fouad\\\", \\\"Badr\\\"] Returns ------- vDataFrame The vDataFrame of the search.\",\n \"result[i] ) trans += \\\" ELSE NULL END)\\\" trans =\",\n \"more information, see utilities.tablesample. See Also -------- vDataFrame[].tail : Returns\",\n \"a value to a specified number of decimal places sign\",\n \"be gathered together to create a new category : 'Others'.\",\n \"'{}' was normalized with the method '{}'.\\\".format( self.alias, method )\",\n \"vColumn using 'avg' (Average). Returns ------- float average See Also\",\n \"ctype, category)] self.parent.__update_catalog__(erase=True, columns=[self.alias]) self.parent.__add_to_history__( \\\"[Apply]: The vColumn '{}' was\",\n \"0, h: float = 0, ax=None, **style_kwds, ): \\\"\\\"\\\" ---------------------------------------------------------------------------\",\n \"): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using multiple statistical aggregations:\",\n \"represents the second argument. Returns ------- vDataFrame self.parent See Also\",\n \"END AS iv FROM ({}) x ORDER BY ord\\\".format( self.alias,\",\n \"datetime, timestamp...) or numerical. q: tuple, optional Tuple including the\",\n \"be similar to the following: (function, type, category) parent: vDataFrame,\",\n \"hyperbolic cosine cot : trigonometric cotangent exp : exponential function\",\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,\",\n \"delimitor of the dummies. drop_first: bool, optional Drops the first\",\n \"gen_tmp_name(schema=schema, name=\\\"view\\\") tmp_model_name = gen_tmp_name(schema=schema, name=\\\"model\\\") assert nbins >= 2,\",\n \"set to True, NULL values will not be considered during\",\n \"nsmallest(self, n: int = 10): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns the n\",\n \"verticapy_agg FROM {} WHERE {} IS NOT NULL GROUP BY\",\n \") else: p_alpha, p_1_alpha = ( self.parent.quantile([alpha, 1 - alpha],\",\n \"[int, float]), (\\\"unit\\\", unit, [str]), (\\\"start\\\", start, [bool]), ] )\",\n \"else: return self.apply(func=\\\"{} - ({})\\\".format(\\\"{}\\\", x)) # ---# def sum(self):\",\n \"close_l = \\\"<\\\", \\\"]\\\" if labels: label = labels[idx] else:\",\n \": Normalization using the MinMax (min and max). (x -\",\n \"than November 1993 the 3rd. area: bool, optional If set\",\n \"categories and merge the other into one unique category. h:\",\n \"( '\\\"{}{}\\\"'.format(prefix, k) if (use_numbers_as_suffix) else '\\\"{}{}\\\"'.format( prefix, str(distinct_elements[k]).replace('\\\"', \\\"_\\\")\",\n \"on type numeric|date\\\" ) if self.isnum(): result = ( self.parent.describe(\",\n \"{}, {}({}) FROM {} GROUP BY {};\\\".format( by[0], fun, self.alias,\",\n \"== [0, 1], TypeError( \\\"vColumn {} must be binary to\",\n \"**style_kwds, ) # ---# def plot( self, ts: str, by:\",\n \"= \\\"The vColumn {} has no mode (only missing values).\\\\nNothing\",\n \"Prefix of the dummies. prefix_sep: str, optional Prefix delimitor of\",\n \"(0.25, 0.75), start_date: Union[str, datetime.datetime, datetime.date] = \\\"\\\", end_date: Union[str,\",\n \"each record of the vColumn. vDataFrame[].extract : Extracts the regular\",\n \"Normalization using the Z-Score (avg and std). (x - avg)\",\n \"[str])]) return self.apply( func=\\\"REGEXP_SUBSTR({}, '{}')\\\".format(\\\"{}\\\", pat.replace(\\\"'\\\", \\\"''\\\")) ) # ---#\",\n \"def drop_outliers( self, threshold: float = 4.0, use_threshold: bool =\",\n \"return self.apply(func=\\\"{} - ({})\\\".format(\\\"{}\\\", x)) # ---# def sum(self): \\\"\\\"\\\"\",\n \"sys.getsizeof(self.transformations) + sys.getsizeof(self.catalog) ) for elem in self.catalog: total +=\",\n \"---# def __init__( self, alias: str, transformations: list = [],\",\n \"True if the vColumn is boolean, False otherwise. Returns -------\",\n \"float, optional The bandwidth of the kernel. kernel: str, optional\",\n \": Discretizes the vColumn. vDataFrame[].label_encode : Encodes the vColumn with\",\n \"to use to sort the data when using TS methods.\",\n \"count, vColumn_min, vColumn_025, vColumn_075, vColumn_max = result sturges = max(\",\n \"\\\"column\\\" in kwargs: column = kwargs[\\\"column\\\"] else: check = False\",\n \"AS {} FROM {}{} LIMIT {} OFFSET {}\\\".format( bin_spatial_to_str(self.category(), self.alias),\",\n \"vColumn(str_sql): \\\"\\\"\\\" --------------------------------------------------------------------------- Python object which that stores all user\",\n \"invalid. max_cardinality: int, optional Maximum number of vColumn distinct elements\",\n \"= 0 limit = \\\" LIMIT {}\\\".format(limit) else: limit =\",\n \"Union[str, datetime.datetime, datetime.date] = \\\"\\\", plot_median: bool = False, ax=None,\",\n \") index_stop = index.stop index_start = index.start if not (isinstance(index_start,\",\n \"__getitem__(self, index): if isinstance(index, slice): assert index.step in (1, None),\",\n \"same_freq : Computes bins with the same number of elements.\",\n \"max_cardinality: int = 8, cat_priority: list = [], ax=None, **style_kwds,\",\n \"not (isinstance(index_start, int)): index_start = 0 if index_start < 0:\",\n \"GROUP (ORDER BY {}) OVER (), PERCENTILE_CONT(1 - {}) WITHIN\",\n \"vDataFrame self.parent See Also -------- vDataFrame[].str_contains : Verifies if the\",\n \"ax Matplotlib axes object See Also -------- vDataFrame[].bar : Draws\",\n \"method=\\\"fetchfirstelem\\\", ) self.parent.__update_catalog__( {\\\"index\\\": [\\\"store_usage\\\"], self.alias: [store_usage]} ) return store_usage\",\n \"transformation instead of the vDataFrame parent and do not apply\",\n \"= \\\"Computing WOE & IV of {} (response = {}).\\\".format(self.alias,\",\n \"\\\"\\\") ) ) # ---# def apply_fun(self, func: str, x:\",\n \"input vColumn. \\\"\\\"\\\" return self.apply(func=\\\"ABS({})\\\") # ---# def add(self, x:\",\n \"6), h: Union[int, float, tuple] = (None, None), ax=None, **style_kwds,\",\n \"(\\\"FLOOR({}) || ''\\\", \\\"varchar\\\", \\\"text\\\") else: trans = (\\\"{} ||\",\n \"Matplotlib axes object See Also -------- vDataFrame.boxplot : Draws the\",\n \"vDataFrame.memory_usage : Returns the vDataFrame memory usage. \\\"\\\"\\\" import sys\",\n \"vColumn to use to partition the data. method: str, optional\",\n \"# ---# def str_slice(self, start: int, step: int): \\\"\\\"\\\" ---------------------------------------------------------------------------\",\n \"= ( name.replace(\\\" \\\", \\\"_\\\") .replace(\\\"/\\\", \\\"_\\\") .replace(\\\",\\\", \\\"_\\\") .replace(\\\"'\\\",\",\n \"See Also -------- vDataFrame[].isdate : Returns True if the vColumn\",\n \"(unit: b). Returns ------- int vColumn expected store usage. See\",\n \"______ __ __ __ __ __ __ __ # /\\\\\",\n \"will be considered as categorical. numcol: str, optional Numerical vColumn\",\n \"verticapy.plot import gen_colors from matplotlib.lines import Line2D colors = gen_colors()\",\n \"vColumn category is date, False otherwise. Returns ------- bool True\",\n \"else \\\"\\\", cmax, cmin, ) else: final_transformation = [ (\",\n \"different than 1.\\\" ) index_stop = index.stop index_start = index.start\",\n \"they occur, and other statistical information. Parameters ---------- k: int,\",\n \"\\\"\\\"\\\"SELECT '{0}' AS 'index', COUNT({1}) AS count, 100 * COUNT({1})\",\n \"(most occurent element). 0ifnull : 0 when the vColumn is\",\n \"cmin == 0: warning_message = \\\"Can not normalize {} using\",\n \"str, copy_name: str = \\\"\\\"): \\\"\\\"\\\" --------------------------------------------------------------------------- Applies a function\",\n \"ORDER BY {} ASC LIMIT {}\\\".format( self.parent.__genSQL__(), self.alias, self.alias, n\",\n \"obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0\",\n \"int = 6, new_category: str = \\\"Others\\\", RFmodel_params: dict =\",\n \"mean encoding with {} as Response Column.\\\".format( self.alias, response )\",\n \"return range_curve_vdf( self, ts, q, start_date, end_date, plot_median, ax=ax, **style_kwds,\",\n \"= result.values[self.alias] elif (method == \\\"cat_stats\\\") and (numcol != \\\"\\\"):\",\n \"[str]), (\\\"nbins\\\", nbins, [int])]) self.parent.are_namecols_in(y) y = self.parent.format_colnames(y) assert self.parent[y].nunique()\",\n \"/ EPOCH / HOUR / ISODOW / ISOWEEK / ISOYEAR\",\n \"elements to display. offset: int, optional Number of elements to\",\n \"elements to return. dropna: bool, optional If set to True,\",\n \"the transformation used instead of the parent vDataFrame. This parameter\",\n \"doesn't work on booleans\\\".format(self.alias) warnings.warn(warning_message, Warning) elif self.isnum(): if method\",\n \"occurent elements and their distributions as percents. Parameters ---------- k:\",\n \"rounds a value to a specified number of decimal places\",\n \"the vColumn. The category will be one of the following:\",\n \"vColumn. \\\"\\\"\\\" check_types([(\\\"limit\\\", limit, [int, float]), (\\\"offset\\\", offset, [int, float])])\",\n \"set to True, the Median will be drawn. ax: Matplotlib\",\n \"NULL GROUP BY {} ORDER BY {}\\\".format( bin_spatial_to_str(self.category(), self.alias), self.alias,\",\n \"MinMax (min and max). (x - min) / (max -\",\n \"\\\"mean\\\": query = \\\"WITH vdf_table AS (SELECT * FROM {})\",\n \"tail of the vColumn. Parameters ---------- limit: int, optional Number\",\n \"func=\\\"(CASE WHEN {} < {} THEN {} WHEN {} >\",\n \"for elem in copy_trans] for elem in sauv: self.catalog[elem] =\",\n \"max( len(self.parent[column].transformations), max_floor ) except: pass max_floor -= len(self.transformations) if\",\n \"self.parent[y].nunique() == 2, TypeError( \\\"vColumn {} must be binary to\",\n \"be drawn. ax: Matplotlib axes object, optional The axes to\",\n \"if (start) else \\\"END\\\" return self.apply( func=\\\"TIME_SLICE({}, {}, '{}', '{}')\\\".format(\",\n \"convert to use to convert the vColumn. If this parameter\",\n \"standard deviation topk : kth most occurent element (ex: top1\",\n \"and not (method == \\\"categorical\\\")) or ( method == \\\"is_numeric\\\"\",\n \"* int(nbins): nth_elems += [str(total)] total += nb where =\",\n \"= \\\"COALESCE({}, {})\\\".format(\\\"{}\\\", val) elif (len(by) == 1) and (self.parent[by[0]].nunique()\",\n \"functions. Parameters ---------- func: list List of the different aggregation.\",\n \"min : Minimum of the vColumn 'of'. max : Maximum\",\n \"Matplotlib axes object \\\"\\\"\\\" columns = [self.alias] check = True\",\n \"Computes the vDataFrame input aggregations. \\\"\\\"\\\" return self.aggregate([\\\"max\\\"]).values[self.alias][0] # ---#\",\n \"== 0: nullifzero = 0 avg, stddev = self.aggregate([\\\"avg\\\", \\\"std\\\"]).values[self.alias]\",\n \"elif ( ((distinct_count < max_cardinality + 1) and (method !=\",\n \"): \\\"\\\"\\\" --------------------------------------------------------------------------- Draws the vColumn Density Plot. Parameters ----------\",\n \"= ( parent, alias, [elem for elem in transformations], )\",\n \"Parameters ---------- n: int, optional Offset. Returns ------- tablesample An\",\n \"close_l, close_r = \\\"<\\\", \\\"<=\\\", \\\"]\\\", \\\"]\\\" else: op1, op2,\",\n \"int(max(math.floor(h), 1)) floor_end = -1 if (self.category() == \\\"int\\\") else\",\n \"returned. By setting this parameter to False, the function's performance\",\n \"elements to be used as categorical. The less frequent elements\",\n \"\\\", \\\".join([quote_ident(column) for column in by]) ) if (by) else\",\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] #\",\n \"/ / # \\\\ / / / # \\\\/ /\",\n \"-------- vDataFrame[].head : Returns the head of the vColumn. vDataFrame[].tail\",\n \"OR events = 0 THEN 0 ELSE ZEROIFNULL(LN(pt_non_events / NULLIFZERO(pt_events)))\",\n \"--------------------------------------------------------------------------- Returns the vColumn memory usage. Returns ------- float vColumn\",\n \"--------------------------------------------------------------------------- Aggregates the vColumn using 'sem' (standard error of mean).\",\n \"the vColumn. The function variable must be composed of two\",\n \"result. For more information, see utilities.tablesample. See Also -------- vDataFrame[].head\",\n \"[store_usage]} ) return store_usage # ---# def str_contains(self, pat: str):\",\n \"), ) executeSQL( \\\"SELECT {} FROM {} LIMIT 1\\\".format( new_column.format(self.alias),\",\n \"self.alias ) warnings.warn(warning_message, Warning) return self elif (n == 1)\",\n \"result[0], result[3], result[4], result[6], result[7], ) elif self.isdate(): min_date =\",\n \"a division operation pow : number raised to the power\",\n \"dtype, get_category_from_vertica_type(ctype=dtype), ) ] self.parent.__add_to_history__( \\\"[AsType]: The vColumn {} was\",\n \"k: int = 30): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns the k most\",\n \"0 cmin, cmax = self.aggregate([\\\"min\\\", \\\"max\\\"]).values[self.alias] if cmax - cmin\",\n \"Applies a function to all the vColumns. vDataFrame.eval : Evaluates\",\n \"\\\"\\\"\\\" check_types([(\\\"limit\\\", limit, [int, float]), (\\\"offset\\\", offset, [int, float])]) if\",\n \"will not be considered during the computation. Returns ------- tablesample\",\n \"kwargs[\\\"cmap\\\"] = gen_cmap()[0] else: if not (\\\"color\\\" in kwargs): from\",\n \"0: index_stop += self.parent.shape()[0] limit = index_stop - index_start if\",\n \"of the different aggregation. aad : average absolute deviation approx_unique\",\n \"\\\"max\\\"]) index = result.values[\\\"index\\\"] result = result.values[self.alias] elif (method ==\",\n \"Forest on a response column to find the most relevant\",\n \"def mean_encode(self, response: str): \\\"\\\"\\\" --------------------------------------------------------------------------- Encodes the vColumn using\",\n \"ORDER BY {} DESC LIMIT {}\\\".format( self.parent.__genSQL__(), self.alias, self.alias, n\",\n \"approx: bool, optional If set to True, the approximate cardinality\",\n \"see utilities.tablesample. See Also -------- vDataFrame[].describe : Computes the vColumn\",\n \"\\\"WHEN {} BETWEEN {} AND {} THEN '[{};{}]' \\\".format( \\\"{}\\\",\",\n \"None ] ), ) executeSQL( \\\"SELECT {}, {} FROM {}\",\n \"float])]) if self.isdate(): return self.apply(func=\\\"TIMESTAMPADD(SECOND, {}, {})\\\".format(x, \\\"{}\\\")) else: return\",\n \") distinct_elements = self.distinct() if distinct_elements not in ([0, 1],\",\n \"dropped. Returns ------- vDataFrame self.parent See Also -------- vDataFrame.fill_outliers :\",\n \"Aggregates the vColumn using 'sem' (standard error of mean). Returns\",\n \"[str]), (\\\"prefix_sep\\\", prefix_sep, [str]), (\\\"drop_first\\\", drop_first, [bool]), (\\\"use_numbers_as_suffix\\\", use_numbers_as_suffix, [bool]),\",\n \"the vColumn with a user defined Encoding. vDataFrame[].discretize : Discretizes\",\n \"return self.parent # ---# def geo_plot(self, *args, **kwargs): \\\"\\\"\\\" ---------------------------------------------------------------------------\",\n \"(numcol != \\\"\\\"): numcol = self.parent.format_colnames(numcol) assert self.parent[numcol].category() in (\\\"float\\\",\",\n \"if copy_name: self.add_copy(name=copy_name) for k in range(max_floor): self.parent[copy_name].transformations += [\",\n \"\\\"ceil\\\", \\\"cos\\\", \\\"cosh\\\", \\\"cot\\\", \\\"exp\\\", \\\"floor\\\", \\\"ln\\\", \\\"log\\\", \\\"log10\\\", \\\"mod\\\",\",\n \"{} ): self.parent, self.alias, self.transformations = ( parent, alias, [elem\",\n \"x: float If the vColumn type is date like (date,\",\n \"Input Start Date. For example, time = '03-11-1993' will filter\",\n \"QueryError( \\\"{}\\\\nError when applying the func 'x -> {}' to\",\n \"BETWEEN {} AND {}) THEN {} ELSE NULL END)\\\".format( \\\"{}\\\",\",\n \"IS NOT NULL GROUP BY {0} ORDER BY COUNT(*)\\\" \\\"\",\n \"return result # ---# def kurtosis(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the\",\n \"ax=ax, **style_kwds) # ---# def category(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns the\",\n \"|_ |~) _ _| _ /~\\\\ _ |. # |_)\\\\/\",\n \"'n' must be greater or equal to 1\\\") where =\",\n \"else str(int(n)) if isinstance(top, decimal.Decimal): top = float(top) self.parent.__update_catalog__( {\\\"index\\\":\",\n \"= 0.75) AS 'approx_75%', APPROXIMATE_PERCENTILE ({3}{4} USING PARAMETERS percentile =\",\n \"else: category, ctype = self.category(), self.ctype() copy_trans = [elem for\",\n \"\\\"mean\\\" if (self.isnum() and self.nunique(True) > 6) else \\\"mode\\\" total\",\n \"\\\"'{}'\\\".format(str(elem[0]).replace(\\\"'\\\", \\\"''\\\")) if elem[0] != None else \\\"NULL\\\", elem[2] if\",\n \"\\\"The vColumn {} has no mode (only missing values).\\\\nNothing was\",\n \"st return self.apply(func=st.decode(str_sql(\\\"{}\\\"), *argv)) # ---# def density( self, by:\",\n \"50): try: result = executeSQL( \\\"SELECT {}, AVG({}), STDDEV({}) FROM\",\n \"... ELSE argv[n] END Returns ------- vDataFrame self.parent See Also\",\n \"not xlim: xmin = self.min() xmax = self.max() else: xmin,\",\n \"element to the vColumn. Parameters ---------- x: float If the\",\n \"+ \\\" WHEN \\\".join(conditions) + \\\" END\\\" self.apply(func=expr) # ---#\",\n \"decode(self, *argv): \\\"\\\"\\\" --------------------------------------------------------------------------- Encodes the vColumn using a user-defined\",\n \"method == \\\"zscore\\\": if n == 0: nullifzero = 0\",\n \"\\\".join( [ \\\"{}, {}\\\".format( \\\"'{}'\\\".format(str(elem[0]).replace(\\\"'\\\", \\\"''\\\")) if elem[0] != None\",\n \"name of the merging category when using the 'topk' method.\",\n \"Vertica’s # speed and built-in analytics and machine learning features.\",\n \"result.values[\\\"woe\\\"] += [\\\"\\\"] result.values[\\\"iv\\\"] += [sum(result[\\\"iv\\\"])] return result # ---#\",\n \"\\\"NULL\\\" if (elem[0] == None) else \\\"'{}'\\\".format(str(elem[0]).replace(\\\"'\\\", \\\"''\\\")) ) result[idx][1]\",\n \"WHERE {} IS NOT NULL LIMIT 0\\\".format( func.replace(\\\"{}\\\", self.alias), self.parent.__genSQL__(),\",\n \"Computes the vDataFrame input aggregations. \\\"\\\"\\\" return self.aggregate([\\\"aad\\\"]).values[self.alias][0] # ---#\",\n \"Other aggregations could work if it is part of the\",\n \"total = self.count() if (method == \\\"mode\\\") and (val ==\",\n \"else: distinct_elements = self.distinct() expr = [\\\"DECODE({}\\\"] text_info = \\\"\\\\n\\\"\",\n \") for elem in result if elem[1] != None ]\",\n \"True if the vColumn category is date. \\\"\\\"\\\" return self.category()\",\n \"of Freedman Diaconis and Sturges. freedman_diaconis : Freedman Diaconis [2\",\n \"'numerical' if the vColumn is numerical , 'categorical' otherwise. categorical\",\n \"str, x: float = 2): \\\"\\\"\\\" --------------------------------------------------------------------------- Applies a default\",\n \"return self.parent one_hot_encode = get_dummies # ---# def head(self, limit:\",\n \"a Python library with scikit-like functionality for conducting # data\",\n \"DECODE({}, {}, NULL))\\\".format( \\\"{}\\\", by[0], \\\", \\\".join( [\\\"{}, {}\\\".format(elem[0], elem[1])\",\n \"method=\\\"view\\\") self.parent.to_db(tmp_view_name) from verticapy.learn.ensemble import ( RandomForestClassifier, RandomForestRegressor, ) drop(tmp_model_name,\",\n \"quantile(1-alpha) if 'use_threshold' is set to False else the lower\",\n \"dummies. drop_first: bool, optional Drops the first dummy to avoid\",\n \": absolute value acos : trigonometric inverse cosine asin :\",\n \"nlargest(self, n: int = 10): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns the n\",\n \"to do all of the above. The idea is simple:\",\n \"Drops outliers in the vColumn. vDataFrame.outliers : Adds a new\",\n \"geopandas plot function. For more information, see: https://geopandas.readthedocs.io/en/latest/docs/reference/api/ geopandas.GeoDataFrame.plot.html Returns\",\n \"\\\"::int\\\" if (self.parent[numcol].isbool()) else \\\"\\\" query, cat = [], self.distinct()\",\n \".replace(\\\"/\\\", \\\"_\\\") .replace(\\\",\\\", \\\"_\\\") .replace(\\\"'\\\", \\\"_\\\") ) expr = \\\"DECODE({},\",\n \"vColumn (delimited by an offset and a limit). Parameters ----------\",\n \"Parameters ---------- k: int, optional Number of most occurent elements\",\n \"percentile = 0.5) AS 'approx_50%', APPROXIMATE_PERCENTILE ({3}{4} USING PARAMETERS percentile\",\n \"unit, [str]), (\\\"start\\\", start, [bool]), ] ) start_or_end = \\\"START\\\"\",\n \"title = \\\"Computing WOE & IV of {} (response =\",\n \"[int, float]), (\\\"nbins\\\", nbins, [float, int]), ] ) if by:\",\n \"/ {} < {}\\\".format( self.alias, result[\\\"avg\\\"][0], result[\\\"std\\\"][0], threshold ) )\",\n \"self, breaks: list, labels: list = [], include_lowest: bool =\",\n \"= \\\", \\\".join(expr) + \\\", {})\\\".format(len(distinct_elements)) self.transformations += [(expr, \\\"int\\\",\",\n \"parameter is empty or invalid. max_cardinality: int/tuple, optional Maximum number\",\n \"the vColumn. Parameters ---------- func: str, Function in pure SQL\",\n \"of the vColumn {}.\\\".format(self.alias), method=\\\"fetchfirstelem\\\", ) self.parent.__update_catalog__( {\\\"index\\\": [\\\"store_usage\\\"], self.alias:\",\n \"cmax - cmin == 0: warning_message = \\\"Can not normalize\",\n \"Returns the category of the vColumn. The category will be\",\n \"order_by, [list]), ] ) method = method.lower() self.parent.are_namecols_in([elem for elem\",\n \"= 5): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns the tail of the vColumn.\",\n \"[\\\"zscore\\\", \\\"robust_zscore\\\", \\\"minmax\\\"]), (\\\"by\\\", by, [list]), (\\\"return_trans\\\", return_trans, [bool]), ]\",\n \"/ / / # \\\\/ / / # / /\",\n \"Parent of the vColumn. One vDataFrame can have multiple children\",\n \"{}, \\\"spearman\\\": {}, \\\"spearmand\\\": {}, \\\"kendall\\\": {}, \\\"cramer\\\": {}, \\\"biserial\\\":\",\n \"vColumn. \\\"\\\"\\\" check_types( [ (\\\"breaks\\\", breaks, [list]), (\\\"labels\\\", labels, [list]),\",\n \"--------------------------------------------------------------------------- Fills missing elements in the vColumn with a user-specified\",\n \"the threshold instead of the 'alpha' parameter. alpha: float, optional\",\n \"vColumn to use to partition the data. bandwidth: float, optional\",\n \"self.aggregate([\\\"kurtosis\\\"]).values[self.alias][0] kurt = kurtosis # ---# def label_encode(self): \\\"\\\"\\\" ---------------------------------------------------------------------------\",\n \"trigonometric cosine cosh : hyperbolic cosine cot : trigonometric cotangent\",\n \"+ 5). of: str, optional The vColumn to use to\",\n \"mean encoding of a response. \\\"\\\"\\\" import verticapy.stats as st\",\n \"Uses the Gaussian distribution to define the outliers. After normalizing\",\n \"___\\\\ /\\\\ __ \\\\ /\\\\ \\\\ /\\\\ \\\\/\\\\ \\\\ /\\\\\",\n \"either express or implied. # See the License for the\",\n \"self.alias, self.alias, n ) title = \\\"Reads {} {} largest\",\n \": Returns the vDataFrame expected store usage. \\\"\\\"\\\" pre_comp =\",\n \"Regular expression to replace. value: str, optional New value. Returns\",\n \"verticapy.utilities import * from verticapy.toolbox import * from verticapy.errors import\",\n \"absolute value acos : trigonometric inverse cosine asin : trigonometric\",\n \"\\\"SELECT {} FROM (SELECT {} AS {}, {} AS verticapy_agg\",\n \"column in order_by]) new_column = \\\"COALESCE({}, LAST_VALUE({} IGNORE NULLS) OVER\",\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\\\"]\",\n \"nbins: int, optional Number of bins used for the discretization\",\n \"def isbool(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns True if the vColumn is\",\n \"**style_kwds ) model.drop() return result except: model.drop() raise # ---#\",\n \"vColumn based on an aggregation. \\\"\\\"\\\" if isinstance(pie_type, str): pie_type\",\n \"if (dropna) else \\\"\\\" query = \\\"SELECT {} AS {},\",\n \"normalize by grouping by elements, please use a method in\",\n \"descriptive statistics. \\\"\\\"\\\" check_types([(\\\"k\\\", k, [int, float]), (\\\"dropna\\\", dropna, [bool])])\",\n \"'{}')\\\".format( \\\"{}\\\", length, unit.upper(), start_or_end ) ) # ---# def\",\n \"\\\"\\\"), func.replace(\\\"{}\\\", \\\"x\\\"), ) ) return self.parent except Exception as\",\n \"sublist] # ---# def div(self, x: float): \\\"\\\"\\\" --------------------------------------------------------------------------- Divides\",\n \"get_data_types( \\\"SELECT {} AS apply_test_feature FROM {} WHERE {} IS\",\n \"assert len(breaks) >= 2, ParameterError( \\\"Length of parameter 'breaks' must\",\n \"\\\"{}\\\", x) return self.apply(func=expr) # ---# def astype(self, dtype: str):\",\n \"return self.apply( func=\\\"TIME_SLICE({}, {}, '{}', '{}')\\\".format( \\\"{}\\\", length, unit.upper(), start_or_end\",\n \"elements.\\\".format(self.alias, n) return to_tablesample(query, title=title) # ---# def normalize( self,\",\n \"def describe( self, method: str = \\\"auto\\\", max_cardinality: int =\",\n \"head of the vColumn. vDataFrame[].tail : Returns the tail of\",\n \"woe, CASE WHEN non_events = 0 OR events = 0\",\n \"str, optional The name of the merging category when using\",\n \"successfully done.\\\") return self.parent # ---# def median( self, approx:\",\n \"def __getitem__(self, index): if isinstance(index, slice): assert index.step in (1,\",\n \"= aggregate # ---# def apply(self, func: str, copy_name: str\",\n \"= RandomForestRegressor(tmp_model_name) else: model = RandomForestClassifier(tmp_model_name) model.set_params({\\\"n_estimators\\\": 20, \\\"max_depth\\\": 8,\",\n \"discretization. topk : Keeps the topk most frequent categories and\",\n \"---# def slice(self, length: int, unit: str = \\\"second\\\", start:\",\n \"the outliers in the vColumn. vDataFrame.outliers : Adds a new\",\n \"trigonometric cotangent exp : exponential function floor : value down\",\n \"i] THEN argv[2 * i + 1] ... ELSE argv[n]\",\n \"!= None): return pre_comp assert n >= 1, ParameterError(\\\"Parameter 'n'\",\n \"---------- func: str Function to use to transform the vColumn.\",\n \"return pre_comp store_usage = executeSQL( \\\"SELECT ZEROIFNULL(SUM(LENGTH({}::varchar))) FROM {}\\\".format( bin_spatial_to_str(self.category(),\",\n \"max, median, unique... depending on the input method. Parameters ----------\",\n \"= [elem for elem in self.transformations] total = self.count() if\",\n \"# Special Methods # # ---# def __init__( self, alias:\",\n \"'categorical' otherwise. categorical : Uses only categorical aggregations during the\",\n \"] ax.set_title(\\\"KernelDensity\\\") ax.legend( custom_lines, columns, title=by, loc=\\\"center left\\\", bbox_to_anchor=[1, 0.5],\",\n \"= max( float(vColumn_max - vColumn_min) / int(math.floor(math.log(count, 2) + 2)),\",\n \"vDataFrame.donut : Draws the donut chart of the vColumn based\",\n \"was renamed '{}'.\\\".format(old_name, new_name) ) return parent # ---# def\",\n \"6, numcol: str = \\\"\\\" ): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the\",\n \"------- list Distinct caterogies of the vColumn. See Also --------\",\n \"use for the discretization. topk : Keeps the topk most\",\n \"] ), ) stddev = \\\"DECODE({}, {}, NULL)\\\".format( by[0], \\\",\",\n \"= \\\"<\\\", \\\"]\\\" if labels: label = labels[idx] else: label\",\n \"vColumn. The category will be one of the following: date\",\n \"method == \\\"0ifnull\\\": category, ctype = \\\"int\\\", \\\"bool\\\" else: category,\",\n \"skip. Returns ------- tablesample An object containing the result. For\",\n \"Returns ------- int vColumn expected store usage. See Also --------\",\n \"will be gathered together to create a new category :\",\n \"will be transformed. Parameters ---------- pat: str regular expression. Returns\",\n \"({}) x ORDER BY ord\\\".format( self.alias, query, ) title =\",\n \"{} WHERE {} IS NOT NULL GROUP BY 1) x\",\n \"updated when the parent vDataFrame is modified. Attributes ---------- alias,\",\n \"ts = self.parent.format_colnames(ts) from verticapy.plot import range_curve_vdf return range_curve_vdf( self,\",\n \"topk : Keeps the topk most frequent categories and merge\",\n \"check = True if len(args) > 0: column = args[0]\",\n \"(Time Series) vColumn to use to order the data. The\",\n \"\\\"silverman\\\"]), (\\\"bandwidth\\\", bandwidth, [int, float]), (\\\"nbins\\\", nbins, [float, int]), ]\",\n \"] ) method = method.lower() if self.isnum() and method ==\",\n \"import hist return hist(self, method, of, max_cardinality, nbins, h, ax=ax,\",\n \"else \\\"\\\" ) order_by_ts = \\\", \\\".join([quote_ident(column) + desc for\",\n \"sem(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using 'sem' (standard error\",\n \"will be created using the input Name. Returns ------- vDataFrame\",\n \"if self.category() == \\\"int\\\": best_h = max(math.floor(best_h), 1) return best_h\",\n \"== 0: warning_message = \\\"Can not normalize {} using a\",\n \"can drastically decrease. Returns ------- float quantile (or approximate quantile).\",\n \"vColumns. \\\"\\\"\\\" if isinstance(cat_priority, str) or not (isinstance(cat_priority, Iterable)): cat_priority\",\n \"optional If set to True, draw a Step Plot. ax:\",\n \"result[6], result[7], ) elif self.isdate(): min_date = self.min() table =\",\n \"y, self.parent.__genSQL__(), ) query = \\\"SELECT {}, MIN(ord) AS ord,\",\n \"the method 'smart'.\\\" ) assert response, ParameterError( \\\"Parameter 'response' can\",\n \"\\\"approx_75%\\\", \\\"max\\\", ] if method != \\\"cat_stats\\\": values = {\",\n \"min_date = self.min() table = \\\"(SELECT DATEDIFF('second', '{}'::timestamp, {}) AS\",\n \": Creates a new feature by evaluating some conditions. vDataFrame[].discretize\",\n \"verticapy_agg DESC\\\".format( self.alias, bin_spatial_to_str(self.category(), self.alias), self.alias, kwargs[\\\"agg\\\"], self.parent.__genSQL__(), self.alias, )\",\n \"(isinstance(cat_priority, Iterable)): cat_priority = [cat_priority] check_types( [ (\\\"by\\\", by, [str]),\",\n \"NULL, 0, 1)\\\" elif method in (\\\"mean\\\", \\\"avg\\\", \\\"median\\\"): fun\",\n \"best_h = sturges elif method.lower() in (\\\"freedman_diaconis\\\", \\\"fd\\\"): best_h =\",\n \"was \\\" if verticapy.options[\\\"print_info\\\"]: print(\\\"{} element{}filled.\\\".format(total, conj)) self.parent.__add_to_history__( \\\"[Fillna]: {}\",\n \"1] Returns ------- float optimal bar width. \\\"\\\"\\\" check_types( [(\\\"method\\\",\",\n \"vDataFrame input aggregations. \\\"\\\"\\\" return self.aggregate([\\\"skewness\\\"]).values[self.alias][0] skew = skewness #\",\n \"by: list, optional vColumns used in the partition. order_by: list,\",\n \"different vColumn categories. Parameters ---------- response: str Response vColumn. Returns\",\n \"!= None else \\\"NULL\\\", ) for elem in result if\",\n \"by = self.parent.format_colnames(by) if method == \\\"auto\\\": method = \\\"mean\\\"\",\n \"for the numerical and Mode for the categorical vColumns. bfill\",\n \"optional vColumns used in the partition. order_by: list, optional List\",\n \"category. See Also -------- vDataFrame[].ctype : Returns the vColumn database\",\n \"self.count() > 0 # ---# def __repr__(self): return self.head(limit=verticapy.options[\\\"max_rows\\\"]).__repr__() #\",\n \"LIMIT 0\\\".format( func.replace(\\\"{}\\\", self.alias), self.parent.__genSQL__(), self.alias, ), \\\"apply_test_feature\\\", ) category\",\n \"val != None: new_column = \\\"COALESCE({}, '{}')\\\".format(\\\"{}\\\", val) elif expr:\",\n \"== \\\"donut\\\" else False rose = True if pie_type ==\",\n \"label = f\\\"{close_l}{first_elem};{second_elem}{close_r}\\\" conditions += [ f\\\"'{first_elem}' {op1} {column} AND\",\n \"\\\"The column 'numcol' must be numerical\\\" ) cast = \\\"::int\\\"\",\n \"Sigmoid kernel. silverman : Silverman kernel. nbins: int, optional Maximum\",\n \"processes with its abstractions. Parameters ---------- alias: str vColumn alias.\",\n \"use when the parameter method is set to 'cat_stats'. Returns\",\n \"median and two input quantiles. Parameters ---------- ts: str TS\",\n \") tail.count = self.parent.shape()[0] tail.offset = offset tail.dtype[self.alias] = self.ctype()\",\n \"|____/ / / # _____________ / / # \\\\ /\",\n \"## # # __ __ ______ ______ __ __ __\",\n \"the other types to varchar. same_freq : Computes bins with\",\n \"robust_zscore : Normalization using the Robust Z-Score (median and mad).\",\n \"if it is part of the DB version you are\",\n \"data\\\" ) desc = \\\"\\\" if (method in (\\\"ffill\\\", \\\"pad\\\"))\",\n \"dropna = \\\" WHERE {} IS NOT NULL\\\".format(self.alias) if (dropna)\",\n \"verticapy.plot import ts_plot return ts_plot( self, ts, by, start_date, end_date,\",\n \"/ nbins if h > 0.01: h = round(h, 2)\",\n \"not normalize {} using a Robust Z-Score - The MAD\",\n \"op1, op2, close_l, close_r = \\\"<=\\\", \\\"<\\\", \\\"[\\\", \\\"[\\\" if\",\n \"list): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using the input functions.\",\n \"if the vColumn type is date like). The vColumn will\",\n \"Adds a copy vColumn to the parent vDataFrame. Parameters ----------\",\n \"will be sliced using the floor of the slicing instead\",\n \"the input vColumn based on an aggregation. Parameters ---------- by:\",\n \"greater than the threshold, it will be considered as an\",\n \"std(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using 'std' (Standard Deviation).\",\n \"if method == \\\"robust_zscore\\\": self.catalog[\\\"median\\\"] = 0 self.catalog[\\\"mad\\\"] = 1\",\n \"4.0, use_threshold: bool = True, alpha: float = 0.05 ):\",\n \"# ---# def astype(self, dtype: str): \\\"\\\"\\\" --------------------------------------------------------------------------- Converts the\",\n \") else: if verticapy.options[\\\"print_info\\\"]: print(\\\"Nothing was filled.\\\") self.transformations = [elem\",\n \"advanced analytical function on a specific vColumn. \\\"\\\"\\\" return self.parent.aggregate(func=func,\",\n \"offset, [int, float])]) if offset < 0: offset = max(0,\",\n \"category is date. vDataFrame[].isnum : Returns True if the vColumn\",\n \"new_category.replace(\\\"'\\\", \\\"''\\\"), ), \\\"varchar\\\", \\\"text\\\", ) elif self.isnum() and method\",\n \"int(self.count()) # ---# def __nonzero__(self): return self.count() > 0 #\",\n \"______ / / # \\\\ / / / # \\\\\",\n \") if self.isnum(): result = ( self.parent.describe( method=\\\"numerical\\\", columns=[self.alias], unique=False\",\n \"cmax = \\\"DECODE({}, {}, NULL)\\\".format( by[0], \\\", \\\".join( [ \\\"{},\",\n \"= 1 if drop_first else 0 for k in range(len(distinct_elements)\",\n \"for testing purpose. Returns ------- vDataFrame self.parent See Also --------\",\n \"isinstance(func, str_sql): func = str(func) check_types([(\\\"func\\\", func, [str]), (\\\"copy_name\\\", copy_name,\",\n \"FROM {} LIMIT 1\\\".format( alpha, self.alias, alpha, self.alias, self.parent.__genSQL__() )\",\n \"ax Matplotlib axes object See Also -------- vDataFrame.boxplot : Draws\",\n \"1)) floor_end = -1 if (self.category() == \\\"int\\\") else \\\"\\\"\",\n \"method is 'cat_stats'\\\" ) distinct_count, is_numeric, is_date = ( self.nunique(),\",\n \"), title=\\\"Computing the mode.\\\", method=\\\"fetchall\\\", ) top = None if\",\n \"AS {} FROM {}) VERTICAPY_OPTIMAL_H_TABLE\\\".format( min_date, self.alias, self.alias, self.parent.__genSQL__() )\",\n \"Series) vColumn to use to order the data. The vColumn\",\n \"for numerical vColumns, cast the other types to varchar. same_freq\",\n \"verticapy.plot import spider as spider_plot return spider_plot( self.parent, columns, method,\",\n \"to the parent vDataFrame. Parameters ---------- name: str Name of\",\n \"ctype = self.category(), self.ctype() copy_trans = [elem for elem in\",\n \"'{}', 1, 0)\\\".format( \\\"{}\\\", str(distinct_elements[k]).replace(\\\"'\\\", \\\"''\\\") ) transformations = self.transformations\",\n \"use this file except in compliance with the License. #\",\n \") if return_trans: return \\\"({} - {}) / {}({})\\\".format( self.alias,\",\n \"{}, \\\"kendall\\\": {}, \\\"cramer\\\": {}, \\\"biserial\\\": {}, \\\"regr_avgx\\\": {}, \\\"regr_avgy\\\":\",\n \"= \\\"\\\", by: list = [], order_by: list = [],\",\n \"category of the vColumn. The category will be one of\",\n \"aggregations to gain in performance. The catalog will be updated\",\n \"import boxplot return boxplot(self, by, h, max_cardinality, cat_priority, ax=ax, **style_kwds)\",\n \"the vDataFrame. Dropping a vColumn means simply not selecting it\",\n \"to display. offset: int, optional Number of elements to skip.\",\n \"int, step: int): \\\"\\\"\\\" --------------------------------------------------------------------------- Slices the vColumn. The vColumn\",\n \"error of mean). Returns ------- float sem See Also --------\",\n \"of the learning and scoring phases. xlim: tuple, optional Set\",\n \"of the search. Parameters ---------- val: list List of the\",\n \"object which that stores all user transformations. If the vDataFrame\",\n \"outliers by their respective average. null : Replaces the outliers\",\n \"all_partition = by if method in [\\\"ffill\\\", \\\"pad\\\", \\\"bfill\\\", \\\"backfill\\\"]:\",\n \": Verifies if the regular expression is in each of\",\n \"alias, [elem for elem in transformations], ) self.catalog = {\",\n \"sys.getsizeof(self.catalog) ) for elem in self.catalog: total += sys.getsizeof(elem) return\",\n \"See Also -------- vDataFrame.iv_woe : Computes the Information Value (IV)\",\n \"({})\\\".format(\\\"{}\\\", x)) # ---# def sum(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the\",\n \"elem[1]) for elem in result] ), ) executeSQL( \\\"SELECT {}\",\n \"Interpolation). mean : Average. median : median. mode : mode\",\n \"\\\"int\\\", \\\"int\\\")] self.parent.__update_catalog__(erase=True, columns=[self.alias]) self.catalog[\\\"count\\\"] = self.parent.shape()[0] self.catalog[\\\"percent\\\"] = 100\",\n \"the donut chart of the vColumn based on an aggregation.\",\n \"encoding of a response. \\\"\\\"\\\" import verticapy.stats as st return\",\n \"Maximum number of distinct elements for vColumns 1 and 2\",\n \"------- ax Matplotlib axes object See Also -------- vDataFrame.boxplot :\",\n \"END)\\\".format(lower_when, upper_when, \\\"{}\\\") self.apply(func=func) return self.parent # ---# def count(self):\",\n \"TIME ZONE / TIMEZONE_HOUR / TIMEZONE_MINUTE / WEEK / YEAR\",\n \"0 and 1 that represents the quantile. For example: 0.25\",\n \"threshold. Values lesser than quantile(alpha) or greater than quantile(1-alpha) will\",\n \"\\\"::float\\\" if self.category() == \\\"float\\\" else \\\"\\\" if index <\",\n \"to use to partition the data. h: float, optional Interval\",\n \"print_time_sql=False, ) except: cmax, cmin = ( \\\"MAX({}) OVER (PARTITION\",\n \"1)\\\" elif method in (\\\"mean\\\", \\\"avg\\\", \\\"median\\\"): fun = \\\"MEDIAN\\\"\",\n \"vColumn_025, vColumn_075, vColumn_max = ( result[0], result[3], result[4], result[6], result[7],\",\n \"{name}.\\\\nBy changing the parameter 'name', you'll be able to solve\",\n \"numcol, [str]), ] ) method = method.lower() assert (method !=\",\n \"f\\\"{close_l}{first_elem};{second_elem}{close_r}\\\" conditions += [ f\\\"'{first_elem}' {op1} {column} AND {column} {op2}\",\n \"FROM ({}) x ORDER BY ord\\\".format( self.alias, query, ) title\",\n \"Multiplies the vColumn by the input element. Parameters ---------- x:\",\n \"return to_tablesample(query, title=title) # ---# def normalize( self, method: str\",\n \"If set to True, the information will be stored in\",\n \"the regular expression in each record of the vColumn. vDataFrame[].str_replace\",\n \"categorical (No h will be picked or computed) h: float,\",\n \": median. mode : mode (most occurent element). 0ifnull :\",\n \"if the vColumn category is date, False otherwise. Returns -------\",\n \"str, optional The type of pie chart. auto : Regular\",\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,\",\n \"if cmax - cmin == 0: warning_message = \\\"Can not\",\n \"re, decimal, warnings, datetime from collections.abc import Iterable from typing\",\n \"the first element (Constant Interpolation). mean : Average. median :\",\n \"int): \\\"\\\"\\\" --------------------------------------------------------------------------- Slices the vColumn. The vColumn will be\",\n \"on the vColumn \\\" \\\"or simply because of ambiguous columns\",\n \"= '{}', tree_id = {}, format = 'tabular'))\\\".format( tmp_model_name, i\",\n \"response, [str]), (\\\"nbins\\\", nbins, [int, float]), ( \\\"method\\\", method, [\\\"auto\\\",\",\n \"\\\"\\\"\\\" check_types([(\\\"start\\\", start, [int, float]), (\\\"step\\\", step, [int, float])]) return\",\n \"able to solve this issue.\\\" ) new_vColumn = vColumn( name,\",\n \"used for testing purpose. Returns ------- vDataFrame self.parent See Also\",\n \"of a numerical column for each vColumn category. In this\",\n \"idx in range(len(breaks) - 1): first_elem, second_elem = breaks[idx], breaks[idx\",\n \"the data. The vColumn type must be date like (date,\",\n \"code generation will be slower if the vDataFrame has been\",\n \"\\\"\\\"\\\" return self.aggregate([\\\"sem\\\"]).values[self.alias][0] # ---# def skewness(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates\",\n \"the k most occurent elements and their distributions as percents.\",\n \"the quantile. For example: 0.25 represents Q1. approx: bool, optional\",\n \"result.values[self.alias] elif (method == \\\"cat_stats\\\") and (numcol != \\\"\\\"): numcol\",\n \"_ |. # |_)\\\\/ |_)(_|(_|| \\\\_/|_|(_||| # / # ____________\",\n \"Encodes the vColumn with Label Encoding. vDataFrame[].get_dummies : Encodes the\",\n \"best splits when 'method' is set to 'smart'. A RF\",\n \"\\\"[\\\" if idx == 0 and include_lowest: op1, close_l =\",\n \"1 and 2 bars. It is only valid if the\",\n \"**style_kwds, ): \\\"\\\"\\\" --------------------------------------------------------------------------- Draws the vColumn Density Plot. Parameters\",\n \"vColumn. \\\"\\\"\\\" check_types([(\\\"x\\\", x, [int, float])]) return self.apply(func=\\\"{} * ({})\\\".format(\\\"{}\\\",\",\n \"Aggregates the vColumn using 'unique' (cardinality). Parameters ---------- approx: bool,\",\n \"range(max_floor): self.transformations += [(\\\"{}\\\", self.ctype(), self.category())] self.transformations += [(func, ctype,\",\n \"[0], [0], color=updated_dict(param, style_kwds, idx)[\\\"color\\\"], lw=4, ), ] ax.set_title(\\\"KernelDensity\\\") ax.legend(\",\n \"# \\\\/ (/_| | |(_(_|| \\\\/ # / # VerticaPy\",\n \"int, optional Maximum number of nbins used for the discretization\",\n \"# ---# def median( self, approx: bool = True, ):\",\n \"representing the outliers threshold. Values lesser than quantile(alpha) or greater\",\n \"to cut the vColumn. labels: list, optional Labels used to\",\n \"\\\"approx_25%\\\", \\\"approx_50%\\\", \\\"approx_75%\\\", \\\"max\\\", ] if method != \\\"cat_stats\\\": values\",\n \"] ) if func not in (\\\"log\\\", \\\"mod\\\", \\\"pow\\\", \\\"round\\\"):\",\n \"'tabular'))\\\".format( tmp_model_name, i ) for i in range(parameters[\\\"n_estimators\\\"]) ] query\",\n \"= 1): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns the nth most occurent element.\",\n \"datetime.date] = \\\"\\\", plot_median: bool = False, ax=None, **style_kwds, ):\",\n \"\\\"\\\"\\\" return self.aggregate([\\\"stddev\\\"]).values[self.alias][0] stddev = std # ---# def store_usage(self):\",\n \"[ \\\"auto\\\", \\\"mode\\\", \\\"0ifnull\\\", \\\"mean\\\", \\\"avg\\\", \\\"median\\\", \\\"ffill\\\", \\\"pad\\\", \\\"bfill\\\",\",\n \"sort the data when using TS methods. Returns ------- vDataFrame\",\n \"prefix, [str]), (\\\"prefix_sep\\\", prefix_sep, [str]), (\\\"drop_first\\\", drop_first, [bool]), (\\\"use_numbers_as_suffix\\\", use_numbers_as_suffix,\",\n \"trans += \\\" ELSE NULL END)\\\" trans = (trans, \\\"varchar\\\",\",\n \"result. For more information, see utilities.tablesample. See Also -------- vDataFrame[].describe\",\n \"of that relation. vColumns simplify several processes with its abstractions.\",\n \"self.parent.__add_to_history__( \\\"[Drop]: vColumn {} was deleted from the vDataFrame.\\\".format(self.alias) )\",\n \"transformed multiple times, so it's better practice to use this\",\n \"print_time_sql=False, ) except: new_column = \\\"COALESCE({}, {}({}) OVER (PARTITION BY\",\n \") ) return self.parent # ---# def aggregate(self, func: list):\",\n \"of the vColumn. Parameters ---------- ts: str TS (Time Series)\",\n \"distinct_elements = self.distinct() if distinct_elements not in ([0, 1], [1,\",\n \"[bool]), ] ) self.parent.are_namecols_in(ts) ts = self.parent.format_colnames(ts) if by: self.parent.are_namecols_in(by)\",\n \"in catalog: self.catalog[elem] = catalog[elem] # ---# def __getitem__(self, index):\",\n \"kernel.lower() from verticapy.learn.neighbors import KernelDensity schema = verticapy.options[\\\"temp_schema\\\"] if not\",\n \"= {\\\"color\\\": colors[idx % len(colors)]} ax = self.parent.search( \\\"{} =\",\n \"= [] columns = self.parent[by].distinct() for idx, column in enumerate(columns):\",\n \": kth most occurent element density unique : cardinality (count\",\n \"float(values[elem][i]) return tablesample(values) # ---# def discretize( self, method: str\",\n \"= \\\"winsorize\\\", threshold: float = 4.0, use_threshold: bool = True,\",\n \"first dummy to avoid the creation of correlated features. use_numbers_as_suffix:\",\n \"list = [], include_lowest: bool = True, right: bool =\",\n \"threshold instead of the 'alpha' parameter. alpha: float, optional Number\",\n \": 0 when the vColumn is null, 1 otherwise. expr:\",\n \"the Plot. start_date: str / date, optional Input Start Date.\",\n \"k) ] text_info += \\\"\\\\t{} => {}\\\".format(distinct_elements[k], k) expr =\",\n \"{} using a Z-Score - The Standard Deviation is null\",\n \"(\\\"value\\\", value, [str])]) return self.apply( func=\\\"REGEXP_REPLACE({}, '{}', '{}')\\\".format( \\\"{}\\\", to_replace.replace(\\\"'\\\",\",\n \"of most occurent elements to return. dropna: bool, optional If\",\n \"self.alias), self.parent.__genSQL__(), ), title=\\\"Computing the Store Usage of the vColumn\",\n \"bin_spatial_to_str(self.category(), self.alias), self.alias, self.parent.__genSQL__(), self.parent.__get_last_order_by__(), limit, offset, ), title=title, )\",\n \"< 50): try: if fun == \\\"MEDIAN\\\": fun = \\\"APPROXIMATE_MEDIAN\\\"\",\n \"+= \\\"WHEN {} BETWEEN {} AND {} THEN '[{};{}]' \\\".format(\",\n \"*argv): \\\"\\\"\\\" --------------------------------------------------------------------------- Encodes the vColumn using a user-defined encoding.\",\n \"\\\"_\\\")) assert name.replace('\\\"', \\\"\\\"), EmptyParameter( \\\"The parameter 'name' must not\",\n \"return int(self.count()) # ---# def __nonzero__(self): return self.count() > 0\",\n \"for elem in self.catalog: sauv[elem] = self.catalog[elem] self.parent.__update_catalog__(erase=True, columns=[self.alias]) total\",\n \"= '{}'\\\".format( bin_spatial_to_str(self.category(), self.alias), category, ) ) query += [lp\",\n \"({}) x\\\".format( self.alias, query, ) query = \\\"SELECT {} AS\",\n \"plot on. **style_kwds Any optional parameter to pass to the\",\n \"approximate quantile is returned. By setting this parameter to False,\",\n \"> {} THEN {} \\\".format(\\\"{}\\\", upper, upper) if (isinstance(upper, (float,\",\n \"'x -> {}'.\\\".format( copy_name.replace('\\\"', \\\"\\\"), func.replace(\\\"{}\\\", \\\"x\\\"), ) ) else:\",\n \"lw=4, ), ] ax.set_title(\\\"KernelDensity\\\") ax.legend( custom_lines, columns, title=by, loc=\\\"center left\\\",\",\n \"---# def quantile(self, x: float, approx: bool = True): \\\"\\\"\\\"\",\n \"the vColumn {}.\\\".format(self.alias), method=\\\"fetchfirstelem\\\", ) self.parent.__update_catalog__( {\\\"index\\\": [\\\"store_usage\\\"], self.alias: [store_usage]}\",\n \"type date like. Optimized h will be computed if the\",\n \"solve this issue.\\\" ) new_vColumn = vColumn( name, parent=self.parent, transformations=[item\",\n \"float): \\\"\\\"\\\" --------------------------------------------------------------------------- Subtracts the input element from the vColumn.\",\n \"(elem[1] == None) else str(elem[1]) new_column = \\\"COALESCE({}, DECODE({}, {},\",\n \"to use to compute the optimal h. auto : Combination\",\n \"be greater or equal to 1\\\") where = \\\" WHERE\",\n \"schema = \\\"public\\\" name = gen_tmp_name(schema=schema, name=\\\"kde\\\") if isinstance(xlim, (tuple,\",\n \"except: pass self.parent.__add_to_history__( \\\"[Discretize]: The vColumn {} was discretized.\\\".format(self.alias) )\",\n \"WHERE {} IS NOT NULL\\\".format(self.alias) if (dropna) else \\\"\\\" query\",\n \"sauv: self.catalog[elem] = sauv[elem] return self.parent # ---# def geo_plot(self,\",\n \"aggregations. \\\"\\\"\\\" check_types([(\\\"dropna\\\", dropna, [bool]), (\\\"n\\\", n, [int, float])]) if\",\n \"columns = self.parent[by].distinct() for idx, column in enumerate(columns): param =\",\n \"0.5], ) ax.set_xlabel(self.alias) return ax kernel = kernel.lower() from verticapy.learn.neighbors\",\n \"\\\".join( [ \\\"'{}'\\\".format(str(elem).replace(\\\"'\\\", \\\"''\\\")) for elem in distinct ] ),\",\n \"filled.\\\") self.transformations = [elem for elem in copy_trans] for elem\",\n \"Normalization using the Robust Z-Score (median and mad). (x -\",\n \"numerical. q: tuple, optional Tuple including the 2 quantiles used\",\n \"will be dropped. Returns ------- vDataFrame self.parent See Also --------\",\n \"[bool]), (\\\"step\\\", step, [bool]), ] ) self.parent.are_namecols_in(ts) ts = self.parent.format_colnames(ts)\",\n \"NameError( f\\\"A vColumn has already the alias {new_name}.\\\\nBy changing the\",\n \"all_cols: try: if (quote_ident(column) in func) or ( re.search( re.compile(\\\"\\\\\\\\b{}\\\\\\\\b\\\".format(column.replace('\\\"',\",\n \"self.parent.are_namecols_in(of) of = self.parent.format_colnames(of) from verticapy.plot import bar return bar(self,\",\n \"query = \\\"SELECT {} AS index, non_events, events, pt_non_events, pt_events,\",\n \"= 0, ax=None, **style_kwds, ): \\\"\\\"\\\" --------------------------------------------------------------------------- Draws the histogram\",\n \"do all of the above. The idea is simple: instead\",\n \"of digits to keep after the comma. Returns ------- vDataFrame\",\n \"IS NOT NULL) VERTICAPY_SUBTABLE {}\\\".format( self.alias, self.alias, self.alias, self.parent.__genSQL__(), self.alias,\",\n \"PARAMETERS percentile = 0.25) AS 'approx_25%', APPROXIMATE_PERCENTILE ({3}{4} USING PARAMETERS\",\n \"(\\\"return_enum_trans\\\", return_enum_trans, [bool]), ] ) method = method.lower() if self.isnum()\",\n \"Encoding. \\\"\\\"\\\" check_types([(\\\"response\\\", response, [str])]) self.parent.are_namecols_in(response) response = self.parent.format_colnames(response) assert\",\n \"similar to the following: (function, type, category) parent: vDataFrame, optional\",\n \"if mad != 0: if return_trans: return \\\"({} - {})\",\n \"{} THEN {} \\\".format(\\\"{}\\\", upper, upper) if (isinstance(upper, (float, int)))\",\n \"\\\"varchar\\\", \\\"text\\\") else: trans = (\\\"{} || ''\\\", \\\"varchar\\\", \\\"text\\\")\",\n \"vColumn. See Also -------- vDataFrame.topk : Returns the vColumn most\",\n \"Also -------- vDataFrame[].nlargest : Returns the n largest vColumn elements.\",\n \"using 'count' (Number of non-Missing elements). Returns ------- int number\",\n \"self.isdate(): return self.apply(func=\\\"TIMESTAMPADD(SECOND, {}, {})\\\".format(x, \\\"{}\\\")) else: return self.apply(func=\\\"{} +\",\n \"y = self.parent.format_colnames(y) assert self.parent[y].nunique() == 2, TypeError( \\\"vColumn {}\",\n \"filled.\\\".format( self.alias ) warnings.warn(warning_message, Warning) return self.parent if isinstance(val, str):\",\n \"query = \\\"SELECT {} AS {}, {} AS ord, {}::int\",\n \"store_usage(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns the vColumn expected store usage (unit:\",\n \"Line2D colors = gen_colors() if not xlim: xmin = self.min()\",\n \"pie_type.lower() check_types( [ (\\\"method\\\", method, [str]), (\\\"of\\\", of, [str]), (\\\"max_cardinality\\\",\",\n \"the regular expression in each record of the vColumn. vDataFrame[].str_slice\",\n \"\\\"{}\\\", fun, \\\"{}\\\", \\\", \\\".join(by) ) else: new_column = \\\"COALESCE({},\",\n \"vColumn when method is set to 'smart'. return_enum_trans: bool, optional\",\n \"to identify outliers. After normalizing the data (Z-Score), if the\",\n \"def pie( self, method: str = \\\"density\\\", of: str =\",\n \"[elem for elem in transformations], ) self.catalog = { \\\"cov\\\":\",\n \"trained if the response is numerical (except ints and bools),\",\n \"represents the entire relation, a vColumn can be seen as\",\n \"# ---# def mode(self, dropna: bool = False, n: int\",\n \"+ ({})\\\".format(\\\"{}\\\", x)) # ---# def add_copy(self, name: str): \\\"\\\"\\\"\",\n \"must be binary to use iv_woe.\\\".format(y) ) self.parent[y].distinct() trans =\",\n \"Label Encoding. vDataFrame[].get_dummies : Encodes the vColumn with One-Hot Encoding.\",\n \"__ __ ______ ______ __ __ __ __ __ __\",\n \"______ ______ __ __ __ __ __ __ __ #\",\n \"the vDataFrame. \\\"\\\"\\\" if isinstance(val, str) or not (isinstance(val, Iterable)):\",\n \"\\\".join(by) ) else: new_column = \\\"COALESCE({}, {}({}) OVER (PARTITION BY\",\n \"in enumerate(columns): param = {\\\"color\\\": colors[idx % len(colors)]} ax =\",\n \"True if the vColumn category is date, False otherwise. Returns\",\n \"None ] ), ) stddev = \\\"DECODE({}, {}, NULL)\\\".format( by[0],\",\n \"vColumn = argv[2 * i] THEN argv[2 * i +\",\n \"one element to use to order the data\\\" ) desc\",\n \"the entire relation, a vColumn can be seen as one\",\n \"= result sturges = max( float(vColumn_max - vColumn_min) / int(math.floor(math.log(count,\",\n \"(n == 1) else str(int(n)) if isinstance(top, decimal.Decimal): top =\",\n \"COUNT(*) AS _verticapy_cnt_, 100 * COUNT(*) / {} AS percent\",\n \"[bool]), (\\\"use_numbers_as_suffix\\\", use_numbers_as_suffix, [bool]), ] ) distinct_elements = self.distinct() if\",\n \"Aggregates the vColumn using 'product'. Returns ------- float product See\",\n \"store usage (unit: b). Returns ------- int vColumn expected store\",\n \"else: cmax, cmin = ( \\\"MAX({}) OVER (PARTITION BY {})\\\".format(\",\n \"slicing. step: int Size of the slicing. Returns ------- vDataFrame\",\n \"threshold: float = 4.0, use_threshold: bool = True, alpha: float\",\n \"self.alias), category, ) ) query += [lp + tmp_query +\",\n \"method != \\\"robust_zscore\\\": max_floor = 0 for elem in by:\",\n \"\\\"NULLIFZERO\\\" if (nullifzero) else \\\"\\\", cmax, cmin, ), \\\"float\\\", \\\"float\\\",\",\n \"assert (method != \\\"cat_stats\\\") or (numcol), ParameterError( \\\"The parameter 'numcol'\",\n \"1993 the 3rd. area: bool, optional If set to True,\",\n \"- sauv[\\\"min\\\"]) / ( sauv[\\\"max\\\"] - sauv[\\\"min\\\"] ) except: pass\",\n \"length, [int, float]), (\\\"unit\\\", unit, [str]), (\\\"start\\\", start, [bool]), ]\",\n \"\\\"\\\"\\\" return self.apply(func=\\\"DATE_PART('{}', {})\\\".format(field, \\\"{}\\\")) # ---# def decode(self, *argv):\",\n \"division operation pow : number raised to the power of\",\n \"self.parent.format_colnames(of) from verticapy.plot import spider as spider_plot return spider_plot( self.parent,\",\n \"\\\"Parameter 'nbins' must be greater or equals to 2 in\",\n \"the vColumn records. vDataFrame[].str_count : Computes the number of matches\",\n \"{0} IS NOT NULL GROUP BY {0} ORDER BY COUNT(*)\\\"\",\n \"index_start, limit, ) return vDataFrameSQL(query) elif isinstance(index, int): cast =\",\n \"Also -------- vDataFrame.eval : Evaluates a customized expression. \\\"\\\"\\\" check_types([(\\\"name\\\",\",\n \"create a new category : 'Others'. cat_priority: list, optional List\",\n \"import pie return pie( self, method, of, max_cardinality, h, donut,\",\n \"= False, step: bool = False, ax=None, **style_kwds, ): \\\"\\\"\\\"\",\n \"with the same number of elements. same_width : Computes regular\",\n \"______ # / __ `\\\\ / / # | \\\\/\",\n \"{}, \\\"biserial\\\": {}, \\\"regr_avgx\\\": {}, \\\"regr_avgy\\\": {}, \\\"regr_count\\\": {}, \\\"regr_intercept\\\":\",\n \"of: self.parent.are_namecols_in(of) of = self.parent.format_colnames(of) from verticapy.plot import hist return\",\n \"limit: int, optional Number of elements to display. offset: int,\",\n \"int = 6, nbins: int = 0, h: float =\",\n \"\\\"''\\\")) ) # ---# def str_extract(self, pat: str): \\\"\\\"\\\" ---------------------------------------------------------------------------\",\n \"check_types([(\\\"pat\\\", pat, [str])]) return self.apply( func=\\\"REGEXP_COUNT({}, '{}')\\\".format(\\\"{}\\\", pat.replace(\\\"'\\\", \\\"''\\\")) )\",\n \"[int, float]), (\\\"step\\\", step, [int, float])]) return self.apply(func=\\\"SUBSTR({}, {}, {})\\\".format(\\\"{}\\\",\",\n \"nth_elems + [str(count)]) ) query = \\\"SELECT {} FROM (SELECT\",\n \"return self.parent.isin(val) # ---# def isnum(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns True\",\n \"the vColumn records. vDataFrame[].extract : Extracts the regular expression in\",\n \"/ # \\\\/ # _ # \\\\ / _ __|_.\",\n \"SQL code. Note: Dropping a vColumn can make the vDataFrame\",\n \"+= \\\" ELSE NULL END)\\\" trans = (trans, \\\"varchar\\\", \\\"text\\\")\",\n \"will be transformed. Parameters ---------- field: str The field to\",\n \"(\\\"method\\\", method, [\\\"zscore\\\", \\\"robust_zscore\\\", \\\"minmax\\\"]), (\\\"by\\\", by, [list]), (\\\"return_trans\\\", return_trans,\",\n \"Chart of vColumn based on an aggregation. \\\"\\\"\\\" check_types( [\",\n \"copy of the vColumn. \\\"\\\"\\\" check_types([(\\\"new_name\\\", new_name, [str])]) old_name =\",\n \") except: pass if method == \\\"robust_zscore\\\": self.catalog[\\\"median\\\"] = 0\",\n \"in the vColumn with a user-specified rule. Parameters ---------- val:\",\n \"* {} + {}{}) || ']'\\\".format( \\\"{}\\\", h, h, \\\"{}\\\",\",\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\\\"] +=\",\n \"THEN {} ELSE {} END)\\\".format( \\\"{}\\\", p_alpha, mean_alpha, \\\"{}\\\", p_1_alpha,\",\n \"by) by = self.parent.format_colnames(by) if method == \\\"auto\\\": method =\",\n \"the method will return the transformation used instead of the\",\n \"= 1, len(by) if self.isbool(): warning_message = \\\"Normalize doesn't work\",\n \"average. null : Replaces the outliers by the NULL value.\",\n \"aggregations to compute the optimal h.\\\", method=\\\"fetchrow\\\", ) count, vColumn_min,\",\n \"or mod), 'x' represents the second argument. Returns ------- vDataFrame\",\n \"offset tail.dtype[self.alias] = self.ctype() tail.name = self.alias return tail #\",\n \"self.parent.filter( \\\"ABS({} - {}) / {} < {}\\\".format( self.alias, result[\\\"avg\\\"][0],\",\n \"== \\\"float\\\" else \\\"\\\" if index < 0: index +=\",\n \"vDataFrame : Parent of the vColumn. transformations, str : List\",\n \"mean : average median : median min : minimum mode\",\n \"GROUP BY 1) x ORDER BY verticapy_agg DESC\\\".format( self.alias, bin_spatial_to_str(self.category(),\",\n \"p_alpha, p_1_alpha = ( self.parent.quantile([alpha, 1 - alpha], [self.alias]) .transpose()\",\n \"{}, response: str = \\\"\\\", return_enum_trans: bool = False, ):\",\n \"corresponding to the offset. For example, if n = 1\",\n \"AS ord, {}::int AS {} FROM {}\\\".format( trans, self.alias, self.alias,\",\n \"total > 0: try: if \\\"count\\\" in sauv: self.catalog[\\\"count\\\"] =\",\n \"self.alias, max_cardinality ) if distinct_count > max_cardinality: query += (\",\n \") for elem in sauv: if \\\"top\\\" in elem: if\",\n \"if val != None: new_column = \\\"COALESCE({}, '{}')\\\".format(\\\"{}\\\", val) elif\",\n \"in range(max_floor): self.parent[copy_name].transformations += [ (\\\"{}\\\", self.ctype(), self.category()) ] self.parent[copy_name].transformations\",\n \"n ) title = \\\"Reads {} {} smallest elements.\\\".format(n, self.alias)\",\n \"The vColumn {} was discretized.\\\".format(self.alias) ) return self.parent # ---#\",\n \"vDataFrame self.parent See Also -------- vDataFrame[].drop_outliers : Drops outliers in\",\n \"final_transformation = [ ( \\\"({} - {}) / ({})\\\".format(\\\"{}\\\", med,\",\n \"trans = (\\\"FLOOR({}) || ''\\\", \\\"varchar\\\", \\\"text\\\") else: trans =\",\n \"advantage Vertica’s # speed and built-in analytics and machine learning\",\n \"int = 8, cat_priority: list = [], ax=None, **style_kwds, ):\",\n \"the intervals should be closed. If set to True, the\",\n \"\\\\/_____/ \\\\/_____/ \\\\/_____/ \\\\/_____/ \\\\/_/ \\\\/_/ \\\\/_/ \\\\/_/ # #\",\n \"= \\\"auto\\\", max_cardinality: int = 6, numcol: str = \\\"\\\"\",\n \") .transpose() .values[self.alias] ) result = [distinct_count] + result index\",\n \"return self.parent # ---# def distinct(self, **kwargs): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns\",\n \"= kernel.lower() from verticapy.learn.neighbors import KernelDensity schema = verticapy.options[\\\"temp_schema\\\"] if\",\n \"= self.parent.__get_catalog_value__(self.alias, \\\"numh\\\") if pre_comp != \\\"VERTICAPY_NOT_PRECOMPUTED\\\": return pre_comp assert\",\n \"greater than November 1993 the 3rd. plot_median: bool, optional If\",\n \"or numerical. q: tuple, optional Tuple including the 2 quantiles\",\n \") ) # ---# def avg(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the\",\n \"Returns ------- ax Matplotlib axes object See Also -------- vDataFrame[].hist\",\n \"the histogram of the vColumn based on an aggregation. \\\"\\\"\\\"\",\n \"val=None, method: str = \\\"auto\\\", expr: str = \\\"\\\", by:\",\n \"query=query, title=\\\"Computing the equal frequency histogram bins.\\\", method=\\\"fetchall\\\", ) result\",\n \"True): \\\"\\\"\\\" --------------------------------------------------------------------------- Slices and transforms the vColumn using a\",\n \"interquartile range kurtosis : kurtosis jb : Jarque-Bera index mad\",\n \"__ \\\\ /\\\\ \\\\ /\\\\ \\\\/\\\\ \\\\ /\\\\ \\\"-./ \\\\\",\n \"= self.aggregate(func=[\\\"std\\\", \\\"avg\\\"]).transpose().values self.parent.filter( \\\"ABS({} - {}) / {} <\",\n \"upper, [float, int])]) assert (lower != None) or (upper !=\",\n \"able to solve this issue.\\\" ) self.add_copy(new_name) parent = self.drop(add_history=False)\",\n \"\\\"_\\\") + prefix_sep.replace('\\\"', \\\"_\\\") ) n = 1 if drop_first\",\n \"the vColumn. \\\"\\\"\\\" check_types([(\\\"pat\\\", pat, [str])]) return self.apply( func=\\\"REGEXP_COUNT({}, '{}')\",\n \"dict, optional Catalog where each key corresponds to an aggregation.\",\n \"Aggregates the vColumn using the input functions. Parameters ---------- func:\",\n \"q% : q Quantile of the vColumn 'of' (ex: 50%\",\n \"case of discretization using the method 'topk'\\\" ) distinct =\",\n \"was normalized with the method '{}'.\\\".format( self.alias, method ) )\",\n \"zscore : Normalization using the Z-Score (avg and std). (x\",\n \"WHERE {} = '{}'\\\".format( bin_spatial_to_str(self.category(), self.alias), category, ) ) query\",\n \"str, optional Method to use to compute the optimal h.\",\n \"if the vColumn is boolean, False otherwise. Returns ------- bool\",\n \"# You may not use this file except in compliance\",\n \"self.apply(func=\\\"{} + ({})\\\".format(\\\"{}\\\", x)) # ---# def add_copy(self, name: str):\",\n \"), title=\\\"Computing the Store Usage of the vColumn {}.\\\".format(self.alias), method=\\\"fetchfirstelem\\\",\",\n \"range(max_floor): self.transformations += [(\\\"{}\\\", self.ctype(), self.category())] self.transformations += [(new_column, ctype,\",\n \"assert response_cat == [0, 1], TypeError( \\\"vColumn {} must be\",\n \"ALL (SELECT AVG({}) FROM vdf_table WHERE {} > {})\\\".format( self.parent.__genSQL__(),\",\n \"max(math.floor(best_h), 1) return best_h # ---# def nunique(self, approx: bool\",\n \"and transforms the vColumn using a time series rule. Parameters\",\n \"p_alpha, p_1_alpha) ) return self.parent # ---# def dropna(self): \\\"\\\"\\\"\",\n \"'min' (Minimum). Returns ------- float/str minimum See Also -------- vDataFrame.aggregate\",\n \"the input vColumns from the vDataFrame. \\\"\\\"\\\" check_types([(\\\"add_history\\\", add_history, [bool])])\",\n \"the range plot of the vColumn. The aggregations used are\",\n \"self.parent.__genSQL__(), ) query = \\\"SELECT {}, MIN(ord) AS ord, SUM(1\",\n \"The describe method. auto : Sets the method to 'numerical'\",\n \"cut( self, breaks: list, labels: list = [], include_lowest: bool\",\n \"limit: int = 5, offset: int = 0): \\\"\\\"\\\" ---------------------------------------------------------------------------\",\n \"[ ( \\\"({} - {}) / {}({})\\\".format( \\\"{}\\\", avg, \\\"NULLIFZERO\\\"\",\n \"transformations. If the vDataFrame represents the entire relation, a vColumn\",\n \"length of parameter 'labels' + 1 or parameter 'labels' must\",\n \"return self.parent except Exception as e: raise QueryError( \\\"{}\\\\nError when\",\n \"by = [by] check_types( [ (\\\"method\\\", method, [\\\"zscore\\\", \\\"robust_zscore\\\", \\\"minmax\\\"]),\",\n \"[str]), ] ) method = method.lower() assert (method != \\\"cat_stats\\\")\",\n \"In this case, the parameter 'numcol' must be defined. numerical\",\n \"median is returned. By setting this parameter to False, the\",\n \"vDataFrame. This parameter is used for testing purpose. Returns -------\",\n \"{} WHERE {} IS NOT NULL ORDER BY {} ASC\",\n \"0: warning_message = \\\"The method 'robust_zscore' is available only if\",\n \"vColumn based on an aggregation. Parameters ---------- by: str, optional\",\n \"{} FROM {} LIMIT 1\\\".format( avg, stddev, self.parent.__genSQL__() ), print_time_sql=False,\",\n \"self, alias: str, transformations: list = [], parent=None, catalog: dict\",\n \"vColumn Density Plot. Parameters ---------- by: str, optional vColumn to\",\n \"(ex: AVG(column1) + 5). of: str, optional The vColumn to\",\n \"\\\"\\\", prefix_sep: str = \\\"_\\\", drop_first: bool = True, use_numbers_as_suffix:\",\n \"( \\\"'[' || FLOOR({} / {}) * {} || ';'\",\n \"------- vDataFrame self.parent See Also -------- vDataFrame.drop: Drops the input\",\n \"k in range(len(distinct_elements)): expr += [ \\\"'{}', {}\\\".format(str(distinct_elements[k]).replace(\\\"'\\\", \\\"''\\\"), k)\",\n \"vdf_table AS (SELECT * FROM {}) {}\\\".format( self.parent.__genSQL__(), \\\" UNION\",\n \"mod), 'x' represents the second argument. Returns ------- vDataFrame self.parent\",\n \"def isin(self, val: list, *args): \\\"\\\"\\\" --------------------------------------------------------------------------- Looks if some\",\n \"check_types( [ (\\\"alpha\\\", alpha, [int, float]), (\\\"use_threshold\\\", use_threshold, [bool]), (\\\"threshold\\\",\",\n \"# ---# def min(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using\",\n \"the Geospatial object. Parameters ---------- *args / **kwargs Any optional\",\n \"for elem in values: for i in range(len(values[elem])): if isinstance(values[elem][i],\",\n \"sauv: self.catalog[\\\"count\\\"] = int(sauv[\\\"count\\\"]) + total self.catalog[\\\"percent\\\"] = ( 100\",\n \"param = {\\\"color\\\": colors[idx % len(colors)]} ax = self.parent.search( \\\"{}\",\n \"vDataFrame.filter: Filters the data using the input expression. \\\"\\\"\\\" self.parent.filter(\\\"{}\",\n \"FROM {} WHERE {} IS NOT NULL GROUP BY {}\",\n \"int Start of the slicing. step: int Size of the\",\n \"between 0 and 1 that represents the quantile. For example:\",\n \"logic to the data. # # # Modules # #\",\n \"the kernel. kernel: str, optional The method used for the\",\n \"[\\\"name\\\", \\\"dtype\\\"] + index, \\\"value\\\": [self.alias, self.ctype()] + result, }\",\n \"def div(self, x: float): \\\"\\\"\\\" --------------------------------------------------------------------------- Divides the vColumn by\",\n \"check_types([(\\\"func\\\", func, [str]), (\\\"copy_name\\\", copy_name, [str])]) try: try: ctype =\",\n \"more information, see utilities.tablesample. See Also -------- vDataFrame.analytic : Adds\",\n \"the vDataFrame input aggregations. \\\"\\\"\\\" return self.aggregate([\\\"skewness\\\"]).values[self.alias][0] skew = skewness\",\n \"self.alias, self.parent.__genSQL__(), by[0], ), title=\\\"Computing the different categories {} to\",\n \"elements for vColumns 1 and 2 to be used as\",\n \"graphical options. # # VerticaPy aims to do all of\",\n \"categorical. The less frequent elements will be gathered together to\",\n \"to look at the final transformation. Returns ------- vDataFrame self.parent\",\n \"(median absolute deviation). Returns ------- float mad See Also --------\",\n \"(self.parent.is_colname_in(name)), NameError( f\\\"A vColumn has already the alias {name}.\\\\nBy changing\",\n \"Applies a function to the vColumn. \\\"\\\"\\\" check_types( [ (\",\n \"\\\"SELECT {}, MIN(ord) AS ord, SUM(1 - {}) AS non_events,\",\n \"elif self.isnum() and method in (\\\"same_width\\\", \\\"auto\\\"): if not (h)\",\n \"\\\"\\\"\\\" check_types([(\\\"approx\\\", approx, [bool])]) if approx: return self.aggregate(func=[\\\"approx_unique\\\"]).values[self.alias][0] else: return\",\n \"with the func 'x -> {}'.\\\".format( copy_name.replace('\\\"', \\\"\\\"), func.replace(\\\"{}\\\", \\\"x\\\"),\",\n \"expr = \\\"{}({})\\\".format(func.upper(), \\\"{}\\\") else: expr = \\\"{}({}, {})\\\".format(func.upper(), \\\"{}\\\",\",\n \"3rd. plot_median: bool, optional If set to True, the Median\",\n \"xmax = self.max() else: xmin, xmax = xlim custom_lines =\",\n \"= [ column for column in self.parent._VERTICAPY_VARIABLES_[\\\"columns\\\"] ] force_columns.remove(self.alias) executeSQL(\",\n \"in the partition. order_by: list, optional List of the vColumns\",\n \"xmax), ax=ax, **updated_dict(param, style_kwds, idx), ) custom_lines += [ Line2D(\",\n \"---------- new_name: str The new vColumn alias. Returns ------- vDataFrame\",\n \"index_start = 0 if index_start < 0: index_start += self.parent.shape()[0]\",\n \"optional vColumn to use to partition the data. h: float,\",\n \"+ 1 or parameter 'labels' must be empty.\\\" ) conditions,\",\n \"self.catalog[\\\"std\\\"] = 1 elif method == \\\"minmax\\\": self.catalog[\\\"min\\\"] = 0\",\n \"not (is_numeric) or (method == \\\"categorical\\\") ): query = \\\"\\\"\\\"(SELECT\",\n \"var(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using 'var' (Variance). Returns\",\n \"{}.\\\".format( self.alias, dtype ) ) return self.parent except Exception as\",\n \"alias. transformations: list, optional List of the different transformations. Each\",\n \"must be similar to the following: (function, type, category) parent:\",\n \"\\\"SELECT ZEROIFNULL(SUM(LENGTH({}::varchar))) FROM {}\\\".format( bin_spatial_to_str(self.category(), self.alias), self.parent.__genSQL__(), ), title=\\\"Computing the\",\n \"entire relation, a vColumn can be seen as one column\",\n \"aggregations. \\\"\\\"\\\" return self.aggregate([\\\"sum\\\"]).values[self.alias][0] # ---# def tail(self, limit: int\",\n \"to all the vColumns. vDataFrame.eval : Evaluates a customized expression.\",\n \"list: [\\\"Fouad\\\", \\\"Badr\\\"] Returns ------- vDataFrame The vDataFrame of the\",\n \"boolean. vDataFrame[].isdate : Returns True if the vColumn category is\",\n \"ax=None, **style_kwds, ): \\\"\\\"\\\" --------------------------------------------------------------------------- Draws the box plot of\",\n \"k) expr = \\\", \\\".join(expr) + \\\", {})\\\".format(len(distinct_elements)) self.transformations +=\",\n \"vColumn using a user-defined encoding. Parameters ---------- argv: object Any\",\n \"---# def plot( self, ts: str, by: str = \\\"\\\",\",\n \"( \\\"({} - {}) / {}({} - {})\\\".format( \\\"{}\\\", cmin,\",\n \"-------- vDataFrame.outliers : Computes the vDataFrame Global Outliers. \\\"\\\"\\\" if\",\n \"categorical : Uses only categorical aggregations during the computation. cat_stats\",\n \"alpha, [int, float]), (\\\"use_threshold\\\", use_threshold, [bool]), (\\\"threshold\\\", threshold, [int, float]),\",\n \"\\\"label_encode is only available for categorical variables.\\\" ) warnings.warn(warning_message, Warning)\",\n \"flower brackets {}. For example to apply the function: x\",\n \"optional vColumn to use to partition the data. method: str,\",\n \"Discretizes the vColumn. vDataFrame[].get_dummies : Encodes the vColumn with One-Hot\",\n \"(\\\"prefix\\\", prefix, [str]), (\\\"prefix_sep\\\", prefix_sep, [str]), (\\\"drop_first\\\", drop_first, [bool]), (\\\"use_numbers_as_suffix\\\",\",\n \"= method.lower() self.parent.are_namecols_in(by) by = self.parent.format_colnames(by) nullifzero, n = 1,\",\n \"/\\\\ \\\"-./ \\\\ /\\\\ \\\"-.\\\\ \\\\ # \\\\ \\\\ \\\\'/\",\n \"= \\\"auto\\\", expr: str = \\\"\\\", by: list = [],\",\n \"\\\"\\\"\\\" --------------------------------------------------------------------------- Returns True if the vColumn category is date,\",\n \"vColumn using 'mad' (median absolute deviation). Returns ------- float mad\",\n \"vColumn. The vColumn will be transformed. Parameters ---------- pat: str\",\n \"Warning) return self mad, med = self.aggregate([\\\"mad\\\", \\\"approx_median\\\"]).values[self.alias] mad *=\",\n \"following: CENTURY / DAY / DECADE / DOQ / DOW\",\n \") self.parent.filter( \\\"({} BETWEEN {} AND {})\\\".format(self.alias, p_alpha, p_1_alpha) )\",\n \"ax=None, **style_kwds, ): \\\"\\\"\\\" --------------------------------------------------------------------------- Draws the bar chart of\",\n \"Also -------- vDataFrame[].decode : Encodes the vColumn using a user-defined\",\n \"\\\"STDDEV({}) OVER (PARTITION BY {})\\\".format( self.alias, \\\", \\\".join(by) ), )\",\n \"> 0\\\".format(\\\"{}\\\", pat.replace(\\\"'\\\", \\\"''\\\")) ) # ---# def str_count(self, pat:\",\n \"self.head(limit=verticapy.options[\\\"max_rows\\\"]).__repr__() # ---# def _repr_html_(self): return self.head(limit=verticapy.options[\\\"max_rows\\\"])._repr_html_() # ---# def\",\n \"An object containing the result. For more information, see utilities.tablesample.\",\n \"\\\"\\\"\\\" --------------------------------------------------------------------------- Normalizes the input vColumns using the input method.\",\n \"(PARTITION BY {})\\\".format( self.alias, \\\", \\\".join(by) ), ) else: cmax,\",\n \"See Also -------- vDataFrame[].nlargest : Returns the n largest vColumn\",\n \"WITHIN GROUP (ORDER BY {}) OVER (), PERCENTILE_CONT(1 - {})\",\n \"k if k > 0 else \\\"\\\", self.alias ), method=\\\"fetchall\\\",\",\n \"vColumn. Parameters ---------- threshold: float, optional Uses the Gaussian distribution\",\n \"the median) prod : product range : difference between the\",\n \"'{}', tree_id = {}, format = 'tabular'))\\\".format( tmp_model_name, i )\",\n \"{}\\\".format( e, self.alias, dtype ) ) # ---# def avg(self):\",\n \"final_transformation sauv = {} for elem in self.catalog: sauv[elem] =\",\n \"self.catalog[elem] = sauv[elem] elif elem == None: self.catalog[elem] = None\",\n \"self, by: str = \\\"\\\", method: str = \\\"density\\\", of:\",\n \"the vColumn 'of'. max : Maximum of the vColumn 'of'.\",\n \"or not (isinstance(val, Iterable)): val = [val] val += list(args)\",\n \"user-defined encoding. vDataFrame[].discretize : Discretizes the vColumn. vDataFrame[].label_encode : Encodes\",\n \"if val == None: warning_message = \\\"The vColumn {} has\",\n \"'{}')\\\".format(\\\"{}\\\", pat.replace(\\\"'\\\", \\\"''\\\")) ) # ---# def str_replace(self, to_replace: str,\",\n \"the 3rd. end_date: str / date, optional Input End Date.\",\n \"features. It supports the # entire data science life cycle,\",\n \"# ---# def isnum(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns True if the\",\n \"(ex: top1 for the mode) topk_percent : kth most occurent\",\n \"(\\\"float\\\", \\\"int\\\"), TypeError( \\\"The column 'numcol' must be numerical\\\" )\",\n \"sauv[ \\\"std\\\" ] elif method == \\\"minmax\\\": self.catalog[elem] = (sauv[elem]\",\n \"str, by: str = \\\"\\\", start_date: Union[str, datetime.datetime, datetime.date] =\",\n \"pass total = int(total) conj = \\\"s were \\\" if\",\n \"of: str, optional The vColumn to use to compute the\",\n \") executeSQL( \\\"SELECT {}, {} FROM {} LIMIT 1\\\".format( cmax,\",\n \"range kurtosis : kurtosis jb : Jarque-Bera index mad :\",\n \".replace(\\\",\\\", \\\"_\\\") .replace(\\\"'\\\", \\\"_\\\") ) expr = \\\"DECODE({}, '{}', 1,\",\n \"the list will be included. right: bool, optional How the\",\n \"the approximate cardinality is returned. By setting this parameter to\",\n \"aggregation. \\\"\\\"\\\" if isinstance(pie_type, str): pie_type = pie_type.lower() check_types( [\",\n \"warning_message = ( \\\"label_encode is only available for categorical variables.\\\"\",\n \"auto : Combination of Freedman Diaconis and Sturges. freedman_diaconis :\",\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\\\"]\",\n \"area, step, ax=ax, **style_kwds, ) # ---# def product(self): \\\"\\\"\\\"\",\n \"Also -------- vDataFrame.drop: Drops the input vColumns from the vDataFrame.\",\n \"[int, float]), (\\\"use_threshold\\\", use_threshold, [bool]), (\\\"threshold\\\", threshold, [int, float]), ]\",\n \"vColumns used in the partition. order_by: list, optional List of\",\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]\",\n \"\\\"{}\\\", \\\", \\\".join(by) ) elif method in (\\\"ffill\\\", \\\"pad\\\", \\\"bfill\\\",\",\n \"else \\\"\\\", cmax, cmin, ), \\\"float\\\", \\\"float\\\", ) ] if\",\n \"is numerical , 'categorical' otherwise. categorical : Uses only categorical\",\n \"[str])]) old_name = quote_ident(self.alias) new_name = new_name.replace('\\\"', \\\"\\\") assert not\",\n \"AVG({}), STDDEV({}) FROM {} GROUP BY {}\\\".format( by[0], self.alias, self.alias,\",\n \"if nbins <= 0: h = self.numh() else: h =\",\n \"/ NULLIFZERO(pt_events))) END AS woe, CASE WHEN non_events = 0\",\n \"= executeSQL( \\\"SELECT {}, AVG({}), STDDEV({}) FROM {} GROUP BY\",\n \"(Number of non-Missing elements). Returns ------- int number of non-Missing\",\n \"gen_cmap()[0] else: if not (\\\"color\\\" in kwargs): from verticapy.plot import\",\n \"in the vColumn. \\\"\\\"\\\" check_types([(\\\"n\\\", n, [int, float])]) query =\",\n \"datetime.date]), (\\\"area\\\", area, [bool]), (\\\"step\\\", step, [bool]), ] ) self.parent.are_namecols_in(ts)\",\n \"otherwise. Returns ------- bool True if the vColumn is boolean.\",\n \"vColumn using 'max' (Maximum). Returns ------- float/str maximum See Also\",\n \"regular expression. Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].str_contains\",\n \"Drops the vColumn from the vDataFrame. Dropping a vColumn means\",\n \"[str])]) name = quote_ident(name.replace('\\\"', \\\"_\\\")) assert name.replace('\\\"', \\\"\\\"), EmptyParameter( \\\"The\",\n \"(avg and std). (x - avg) / std robust_zscore :\",\n \"item in query_result] index = [\\\"unique\\\", \\\"count\\\"] + [item[0] for\",\n \"# ---# def mul(self, x: float): \\\"\\\"\\\" --------------------------------------------------------------------------- Multiplies the\",\n \"\\\"asin\\\", \\\"atan\\\", \\\"cbrt\\\", \\\"ceil\\\", \\\"cos\\\", \\\"cosh\\\", \\\"cot\\\", \\\"exp\\\", \\\"floor\\\", \\\"ln\\\",\",\n \"[by] check_types( [ (\\\"method\\\", method, [\\\"zscore\\\", \\\"robust_zscore\\\", \\\"minmax\\\"]), (\\\"by\\\", by,\",\n \"the dependent variable. Parameters ---------- y: str Response vColumn. nbins:\",\n \"sauv[\\\"min\\\"]) / ( sauv[\\\"max\\\"] - sauv[\\\"min\\\"] ) except: pass if\",\n \"\\\"WITH vdf_table AS (SELECT * FROM {}) {}\\\".format( self.parent.__genSQL__(), \\\"\",\n \"0, an optimised interval will be computed. nbins: int, optional\",\n \"---------- pat: str regular expression. Returns ------- vDataFrame self.parent See\",\n \"else: trans = (\\\"FLOOR({}) || ''\\\", \\\"varchar\\\", \\\"text\\\") else: trans\",\n \"h, [int, float]), (\\\"response\\\", response, [str]), (\\\"nbins\\\", nbins, [int, float]),\",\n \"\\\"unique\\\": 2, \\\"approx_unique\\\": 2, \\\"prod\\\": 0, }, ) setattr(self.parent, name,\",\n \"for elem in self.catalog: total += sys.getsizeof(elem) return total #\",\n \"nbins will be computed. h: float, optional Interval width of\",\n \"[int, float]), ] ) if use_threshold: result = self.aggregate(func=[\\\"std\\\", \\\"avg\\\"]).transpose().values\",\n \"int]), (\\\"upper\\\", upper, [float, int])]) assert (lower != None) or\",\n \"elif method.lower() in (\\\"freedman_diaconis\\\", \\\"fd\\\"): best_h = fd else: best_h\",\n \"mode.\\\", method=\\\"fetchall\\\", ) top = None if not (result) else\",\n \"numerical value\\\" ) lower_when = ( \\\"WHEN {} < {}\",\n \"most occurent element. Parameters ---------- dropna: bool, optional If set\",\n \"in sauv: self.catalog[elem] = sauv[elem] return self.parent # ---# def\",\n \"usage. \\\"\\\"\\\" pre_comp = self.parent.__get_catalog_value__(self.alias, \\\"store_usage\\\") if pre_comp != \\\"VERTICAPY_NOT_PRECOMPUTED\\\":\",\n \"# entire data science life cycle, uses a ‘pipeline’ mechanism\",\n \"vColumn. If this parameter is equal to 0, an optimised\",\n \"best_h = fd else: best_h = max(sturges, fd) self.parent.__update_catalog__({\\\"index\\\": [\\\"numh\\\"],\",\n \"NULL ORDER BY {} ASC LIMIT {}\\\".format( self.parent.__genSQL__(), self.alias, self.alias,\",\n \"self.isnum() or self.isdate(), TypeError( \\\"cut only works on numerical /\",\n \"== \\\"float\\\"): trans = ( \\\"'[' || FLOOR({} / {})\",\n \") else: query = \\\"SELECT {} FROM (SELECT {} AS\",\n \"and (self.parent[by[0]].nunique() < 50): try: result = executeSQL( \\\"SELECT {},\",\n \"the outliers threshold. Values lesser than quantile(alpha) or greater than\",\n \"30): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns the k most occurent elements, how\",\n \"Also -------- vDataFrame.case_when : Creates a new feature by evaluating\",\n \"bar chart of the vColumn based on an aggregation. Parameters\",\n \"caterogies of the vColumn. See Also -------- vDataFrame.topk : Returns\",\n \"of the 'alpha' parameter. alpha: float, optional Number representing the\",\n \"== None: mean_alpha = \\\"NULL\\\" if mean_1_alpha == None: mean_alpha\",\n \"float]), (\\\"offset\\\", offset, [int, float])]) if offset < 0: offset\",\n \"a function to all the vColumns. vDataFrame.eval : Evaluates a\",\n \"vColumn with One-Hot Encoding. vDataFrame[].mean_encode : Encodes the vColumn using\",\n \"model_name = '{}', tree_id = {}, format = 'tabular'))\\\".format( tmp_model_name,\",\n \"\\\"float\\\", ) ] if method != \\\"robust_zscore\\\": max_floor = 0\",\n \"query=query, title=\\\"Getting the vColumn element.\\\", method=\\\"fetchfirstelem\\\", ) else: return getattr(self,\",\n \"list will be included. right: bool, optional How the intervals\",\n \"For more information, see utilities.tablesample. See Also -------- vDataFrame.iv_woe :\",\n \"---# def apply_fun(self, func: str, x: float = 2): \\\"\\\"\\\"\",\n \"if offset < 0: offset = max(0, self.parent.shape()[0] - limit)\",\n \"largest elements.\\\".format(self.alias, n) return to_tablesample(query, title=title) # ---# def normalize(\",\n \"title=title) result.values[\\\"index\\\"] += [\\\"total\\\"] result.values[\\\"non_events\\\"] += [sum(result[\\\"non_events\\\"])] result.values[\\\"events\\\"] += [sum(result[\\\"events\\\"])]\",\n \"range(max_floor): self.parent[copy_name].transformations += [ (\\\"{}\\\", self.ctype(), self.category()) ] self.parent[copy_name].transformations +=\",\n \"style_kwds, idx), ) custom_lines += [ Line2D( [0], [0], color=updated_dict(param,\",\n \"one_hot_encode = get_dummies # ---# def head(self, limit: int =\",\n \"each key corresponds to an aggregation. vColumns will memorize the\",\n \"{\\\"n_estimators\\\": 20, \\\"max_depth\\\": 10} to train a Random Forest with\",\n \"Computes the Information Value (IV) / Weight Of Evidence (WOE)\",\n \"idx), ) custom_lines += [ Line2D( [0], [0], color=updated_dict(param, style_kwds,\",\n \"in each record of the vColumn. vDataFrame[].extract : Extracts the\",\n \"model = RandomForestRegressor(tmp_model_name) else: model = RandomForestClassifier(tmp_model_name) model.set_params({\\\"n_estimators\\\": 20, \\\"max_depth\\\":\",\n \"Also -------- vDataFrame[].isdate : Returns True if the vColumn category\",\n \"the mean encoding of a response. \\\"\\\"\\\" import verticapy.stats as\",\n \"/ DOW / DOY / EPOCH / HOUR / ISODOW\",\n \"(self.parent[numcol].isbool()) else \\\"\\\" query, cat = [], self.distinct() if len(cat)\",\n \"Encoding. vDataFrame[].get_dummies : Encodes the vColumn with One-Hot Encoding. \\\"\\\"\\\"\",\n \"regular expression matches in each of the vColumn record by\",\n \"\\\"\\\"\\\" --------------------------------------------------------------------------- Returns the k most occurent elements, how often\",\n \"= -1 if (self.category() == \\\"int\\\") else \\\"\\\" if (h\",\n \"func: list List of the different aggregation. aad : average\",\n \"idx == 0 and include_lowest: op1, close_l = \\\"<=\\\", \\\"[\\\"\",\n \"vColumn is boolean. vDataFrame[].isdate : Returns True if the vColumn\",\n \"= \\\"(CASE \\\" for i in range(1, n): trans +=\",\n \"\\\"\\\"\\\" --------------------------------------------------------------------------- Returns the n smallest elements in the vColumn.\",\n \"gen_tmp_name(schema=schema, name=\\\"model\\\") assert nbins >= 2, ParameterError( \\\"Parameter 'nbins' must\",\n \"function: x -> x^2 + 2 use \\\"POWER({}, 2) +\",\n \"vColumn 'of'. q% : q Quantile of the vColumn 'of'\",\n \"a specified number of decimal places sign : arithmetic sign\",\n \"\\\"\\\" ) upper_when = ( \\\"WHEN {} > {} THEN\",\n \"{} AS {} FROM {}{} LIMIT {} OFFSET {}\\\".format( bin_spatial_to_str(self.category(),\",\n \"def mul(self, x: float): \\\"\\\"\\\" --------------------------------------------------------------------------- Multiplies the vColumn by\",\n \"(\\\"n\\\", n, [int, float])]) if n == 1: pre_comp =\",\n \"!= \\\"\\\"): numcol = self.parent.format_colnames(numcol) assert self.parent[numcol].category() in (\\\"float\\\", \\\"int\\\"),\",\n \"the missing values. auto : Mean for the numerical and\",\n \"draw an Area Plot. step: bool, optional If set to\",\n \"tail(self, limit: int = 5): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns the tail\",\n \"vDataFrame[].date_part : Extracts a specific TS field from the vColumn.\",\n \"numerical or of type date like. Optimized h will be\",\n \"kernel=kernel, nbins=nbins, xlim=(xmin, xmax), ax=ax, **updated_dict(param, style_kwds, idx), ) custom_lines\",\n \"nbins - 1 ) result = executeSQL( query=query, title=\\\"Computing the\",\n \"1 otherwise. expr: str, optional SQL expression. by: list, optional\",\n \"(\\\"expr\\\", expr, [str]), (\\\"by\\\", by, [list]), (\\\"order_by\\\", order_by, [list]), ]\",\n \"the ceiling. Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].date_part\",\n \"by, [str]), (\\\"method\\\", method, [str]), (\\\"of\\\", of, [str]), (\\\"max_cardinality\\\", max_cardinality,\",\n \"vDataFrame input aggregations. \\\"\\\"\\\" return self.aggregate([\\\"kurtosis\\\"]).values[self.alias][0] kurt = kurtosis #\",\n \") return store_usage # ---# def str_contains(self, pat: str): \\\"\\\"\\\"\",\n \"-------- vDataFrame[].hist : Draws the histogram of the vColumn based\",\n \"evaluate the approximate density function. Increasing this parameter will increase\",\n \"if self.category() == \\\"int\\\": h = int(max(math.floor(h), 1)) floor_end =\",\n \"Any amount of expressions. The expression generated will look like:\",\n \"def store_usage(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns the vColumn expected store usage\",\n \"---# def drop(self, add_history: bool = True): \\\"\\\"\\\" --------------------------------------------------------------------------- Drops\",\n \"# You may obtain a copy of the License at\",\n \"else: expr = \\\"{}({}, {})\\\".format(func.upper(), \\\"{}\\\", x) return self.apply(func=expr) #\",\n \"input 'quantile'. Parameters ---------- x: float A float between 0\",\n \"conj = \\\"s were \\\" if len(all_new_features) > 1 else\",\n \"= 0, pie_type: str = \\\"auto\\\", ax=None, **style_kwds, ): \\\"\\\"\\\"\",\n \"= [elem for elem in copy_trans] for elem in sauv:\",\n \"box plot. The other categories will be filtered. ax: Matplotlib\",\n \"y, query, ) query = \\\"SELECT {}, ord, non_events, events,\",\n \"check_types([(\\\"response\\\", response, [str])]) self.parent.are_namecols_in(response) response = self.parent.format_colnames(response) assert self.parent[response].isnum(), TypeError(\",\n \"power or mod), 'x' represents the second argument. Returns -------\",\n \"LIMIT {}\\\".format( self.parent.__genSQL__(), self.alias, self.alias, n ) title = \\\"Reads\",\n \"in result], } return tablesample(values) # ---# def value_counts(self, k:\",\n \"Deviation). Returns ------- float std See Also -------- vDataFrame.aggregate :\",\n \"the data. h: float, optional Interval width if the vColumn\",\n \"{}\\\".format(elem[0], elem[1]) for elem in result] ), ) executeSQL( \\\"SELECT\",\n \"else: return self.aggregate(func=[\\\"unique\\\"]).values[self.alias][0] # ---# def pie( self, method: str\",\n \"Parameters ---------- x: float A float between 0 and 1\",\n \"elif method == \\\"robust_zscore\\\": if n > 0: warning_message =\",\n \"ts: str, by: str = \\\"\\\", start_date: Union[str, datetime.datetime, datetime.date]\",\n \"2, \\\"prod\\\": 0, }, ) setattr(self.parent, name, new_vColumn) setattr(self.parent, name.replace('\\\"',\",\n \"= (\\\"FLOOR({}) || ''\\\", \\\"varchar\\\", \\\"text\\\") else: trans = (\\\"{}\",\n \"utilities.tablesample. See Also -------- vDataFrame.iv_woe : Computes the Information Value\",\n \"vColumn is numerical. \\\"\\\"\\\" return self.ctype().lower() in (\\\"bool\\\", \\\"boolean\\\") #\",\n \"---# def decode(self, *argv): \\\"\\\"\\\" --------------------------------------------------------------------------- Encodes the vColumn using\",\n \"result. For more information, see utilities.tablesample. See Also -------- vDataFrame[].tail\",\n \"the following mapping:{}\\\".format( self.alias, text_info ) ) return self.parent #\",\n \"if isinstance(val, str) or not (isinstance(val, Iterable)): val = [val]\",\n \"transformation. Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].decode :\",\n \"self.head(limit=verticapy.options[\\\"max_rows\\\"])._repr_html_() # ---# def __setattr__(self, attr, val): self.__dict__[attr] = val\",\n \"WHERE split_value IS NOT NULL GROUP BY 1 ORDER BY\",\n \"5). ax: Matplotlib axes object, optional The axes to plot\",\n \"parameter 'new_name', you'll be able to solve this issue.\\\" )\",\n \"include_lowest: bool, optional If set to True, the lowest element\",\n \"/ # \\\\ / # \\\\/ # _ # \\\\\",\n \"science projects on data stored in Vertica, taking advantage Vertica’s\",\n \"cast, ) tmp_query += ( \\\" WHERE {} IS NULL\\\".format(self.alias)\",\n \"greater than quantile(1-alpha) will be filled. Returns ------- vDataFrame self.parent\",\n \"the vColumn records by an input value. vDataFrame[].str_slice : Slices\",\n \"assert not (self.parent.is_colname_in(new_name)), NameError( f\\\"A vColumn has already the alias\",\n \"See Also -------- vDataFrame[].hist : Draws the histogram of the\",\n \"= 0 self.catalog[\\\"std\\\"] = 1 elif method == \\\"minmax\\\": self.catalog[\\\"min\\\"]\",\n \"of the Random Forest model parameters used to compute the\",\n \"\\\\ # \\\\ \\\\__| \\\\ \\\\_____\\\\ \\\\ \\\\_____\\\\ \\\\ \\\\_____\\\\\",\n \"{}) * {} + {}{}) || ']'\\\".format( \\\"{}\\\", h, h,\",\n \"aggregations during the computation. max_cardinality: int, optional Cardinality threshold to\",\n \"vdf_table GROUP BY {0} ORDER BY COUNT(*) DESC LIMIT {1})\\\"\\\"\\\".format(\",\n \"VerticaPy Modules import verticapy from verticapy.utilities import * from verticapy.toolbox\",\n \"\\\"The response column must be numerical to use a mean\",\n \"fun == \\\"AVG\\\": val = self.avg() elif fun == \\\"MEDIAN\\\":\",\n \"nbins, [int, float]), ] ) if of: self.parent.are_namecols_in(of) of =\",\n \"COUNT(*)\\\" \\\" DESC OFFSET {1}) VERTICAPY_SUBTABLE) ORDER BY count DESC\\\"\",\n \"in all_partition: if len(self.parent[elem].transformations) > max_floor: max_floor = len(self.parent[elem].transformations) max_floor\",\n \"self.numh() else: h = (self.max() - self.min()) * 1.01 /\",\n \"OVER () FROM {} LIMIT 1\\\".format( alpha, self.alias, alpha, self.alias,\",\n \"-------- vDataFrame[].drop_outliers : Drops outliers in the vColumn. vDataFrame.outliers :\",\n \"the vColumn using 'median'. Parameters ---------- approx: bool, optional If\",\n \"[ ( \\\"({} - {}) / ({})\\\".format(\\\"{}\\\", med, mad), \\\"float\\\",\",\n \"their respective average. null : Replaces the outliers by the\",\n \"if isinstance(index_stop, int): if index_stop < 0: index_stop += self.parent.shape()[0]\",\n \"100 self.parent.__add_to_history__( \\\"[Label Encoding]: Label Encoding was applied to the\",\n \"mad != 0: if return_trans: return \\\"({} - {}) /\",\n \"BY 1 ORDER BY 2 DESC LIMIT {}) VERTICAPY_SUBTABLE ORDER\",\n \"categorical (No h will be picked or computed) ax: Matplotlib\",\n \"- self.min()) * 1.01 / nbins if h > 0.01:\",\n \"return tablesample(values) # ---# def discretize( self, method: str =\",\n \"in the vColumn. Parameters ---------- threshold: float, optional Uses the\",\n \"fun == \\\"MEDIAN\\\": val = self.median() new_column = \\\"COALESCE({}, {})\\\".format(\\\"{}\\\",\",\n \"For example, it can be 'minute' 'hour'... start: bool, optional\",\n \"_ # \\\\ / _ __|_. _ _ |_) #\",\n \"gen_colors()[0] if not (\\\"legend\\\" in kwargs): kwargs[\\\"legend\\\"] = True if\",\n \"BY {}) OVER (), PERCENTILE_CONT(1 - {}) WITHIN GROUP (ORDER\",\n \") result = [elem[0] for elem in result] except: drop(tmp_view_name,\",\n \"- {}) AS non_events, SUM({}) AS events FROM ({}) x\",\n \"return self.apply( func=\\\"REGEXP_REPLACE({}, '{}', '{}')\\\".format( \\\"{}\\\", to_replace.replace(\\\"'\\\", \\\"''\\\"), value.replace(\\\"'\\\", \\\"''\\\")\",\n \"vDataFrame.aggregate : Computes the vDataFrame input aggregations. \\\"\\\"\\\" return self.aggregate(func=[\\\"prod\\\"]).values[self.alias][0]\",\n \"under the Apache License, Version 2.0 (the \\\"License\\\"); # You\",\n \"self.aggregate(func=[\\\"approx_unique\\\"]).values[self.alias][0] else: return self.aggregate(func=[\\\"unique\\\"]).values[self.alias][0] # ---# def pie( self, method:\",\n \"Aggregates the vColumn using 'sum'. Returns ------- float sum See\",\n \"else: warning_message = \\\"Can not normalize {} using a Robust\",\n \"See Also -------- vDataFrame.expected_store_usage : Returns the vDataFrame expected store\",\n \"\\\"[Fillna]: {} {} missing value{} filled.\\\".format( total, self.alias, conj, )\",\n \"{})\\\".format( \\\"{}\\\", cmin, \\\"NULLIFZERO\\\" if (nullifzero) else \\\"\\\", cmax, cmin,\",\n \"self.alias, self.alias, self.alias, ) else: query = \\\"SELECT {} FROM\",\n \"== 0 and include_lowest: op1, close_l = \\\"<=\\\", \\\"[\\\" elif\",\n \"self.alias: [top]} ) return top # ---# def mul(self, x:\",\n \"= \\\"WHERE _verticapy_row_nb_ IN ({})\\\".format( \\\", \\\".join([\\\"1\\\"] + nth_elems +\",\n \"int = 6, numcol: str = \\\"\\\" ): \\\"\\\"\\\" ---------------------------------------------------------------------------\",\n \"by: str, optional vColumn to use to partition the TS.\",\n \"] elif method == \\\"minmax\\\": self.catalog[elem] = (sauv[elem] - sauv[\\\"min\\\"])\",\n \"kth most occurent element density unique : cardinality (count distinct)\",\n \"label_encode(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Encodes the vColumn using a bijection from\",\n \"int vColumn cardinality (or approximate cardinality). See Also -------- vDataFrame.aggregate\",\n \"kwargs): kwargs[\\\"figsize\\\"] = (14, 10) return self.parent[columns].to_geopandas(self.alias).plot(*args, **kwargs) # ---#\",\n \"= self.catalog self.parent.__add_to_history__( \\\"[Apply]: The vColumn '{}' was transformed with\",\n \"-> {}'.\\\".format( self.alias.replace('\\\"', \\\"\\\"), func.replace(\\\"{}\\\", \\\"x\\\"), ) ) return self.parent\",\n \"# ---# def spider( self, by: str = \\\"\\\", method:\",\n \"expressions. The expression generated will look like: even: CASE ...\",\n \"trigonometric inverse cosine asin : trigonometric inverse sine atan :\",\n \"vDataFrame.aggregate : Computes the vDataFrame input aggregations. \\\"\\\"\\\" return self.aggregate([\\\"count\\\"]).values[self.alias][0]\",\n \"to use when the parameter method is set to 'cat_stats'.\",\n \"query, nth_elems = nb, [], [] while total < int(float(count\",\n \"to_tablesample(query, title=title).values elif ( ((distinct_count < max_cardinality + 1) and\",\n \": Evaluates a customized expression. \\\"\\\"\\\" check_types([(\\\"name\\\", name, [str])]) name\",\n \"2, ParameterError( \\\"Parameter 'k' must be greater or equals to\",\n \"[\\\"top{}\\\".format(n)], self.alias: [top]} ) return top # ---# def mul(self,\",\n \"AS apply_test_feature FROM {} WHERE {} IS NOT NULL LIMIT\",\n \"\\\"_\\\") ) ) name = ( name.replace(\\\" \\\", \\\"_\\\") .replace(\\\"/\\\",\",\n \": Computes the vDataFrame Global Outliers. \\\"\\\"\\\" if isinstance(by, str):\",\n \"encoding. Parameters ---------- argv: object Any amount of expressions. The\",\n \"str = \\\"winsorize\\\", threshold: float = 4.0, use_threshold: bool =\",\n \"= [], include_lowest: bool = True, right: bool = True,\",\n \"\\\"dtype\\\"] + index, \\\"value\\\": [self.alias, self.ctype()] + result, } if\",\n \"n largest vColumn elements. Parameters ---------- n: int, optional Offset.\",\n \"Returns ------- float product See Also -------- vDataFrame.aggregate : Computes\",\n \"= pie_type.lower() check_types( [ (\\\"method\\\", method, [str]), (\\\"of\\\", of, [str]),\",\n \"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\\\" in sauv: self.catalog[\\\"count\\\"] = sauv[\\\"count\\\"] self.catalog[\\\"percent\\\"] = ( 100\",\n \"The other categories will be filtered. ax: Matplotlib axes object,\",\n \"ax=ax, **style_kwds ) model.drop() return result except: model.drop() raise #\",\n \"vColumn from the vDataFrame. Dropping a vColumn means simply not\",\n \"warnings.warn(warning_message, Warning) return self elif n == 1: try: result\",\n \"range plot of the vColumn. The aggregations used are the\",\n \"Also -------- vDataFrame[].slice : Slices the vColumn using a time\",\n \"* {} || ';' || (FLOOR({} / {}) * {}\",\n \"input value. The vColumn will be transformed. Parameters ---------- to_replace:\",\n \"> {})\\\".format( self.parent.__genSQL__(), self.alias, self.alias, p_alpha, self.alias, self.alias, p_1_alpha, )\",\n \"optional Maximum number of the vColumn distinct elements to be\",\n \"{}, {})\\\".format(x, \\\"{}\\\")) else: return self.apply(func=\\\"{} + ({})\\\".format(\\\"{}\\\", x)) #\",\n \"RFmodel_params, [dict]), (\\\"return_enum_trans\\\", return_enum_trans, [bool]), (\\\"h\\\", h, [int, float]), (\\\"response\\\",\",\n \"# ---# def iv_woe(self, y: str, nbins: int = 10):\",\n \"catalog={ \\\"min\\\": 0, \\\"max\\\": 1, \\\"count\\\": self.parent.shape()[0], \\\"percent\\\": 100.0, \\\"unique\\\":\",\n \") count, vColumn_min, vColumn_025, vColumn_075, vColumn_max = ( result[0], result[3],\",\n \"vColumn distinct elements to be used as categorical (No h\",\n \"value up to the next whole number cos : trigonometric\",\n \"else \\\"\\\" if (h > 1) or (self.category() == \\\"float\\\"):\",\n \"approx: return self.aggregate(func=[\\\"approx_unique\\\"]).values[self.alias][0] else: return self.aggregate(func=[\\\"unique\\\"]).values[self.alias][0] # ---# def pie(\",\n \"field from the vColumn. \\\"\\\"\\\" check_types( [ (\\\"length\\\", length, [int,\",\n \"func: str, copy_name: str = \\\"\\\"): \\\"\\\"\\\" --------------------------------------------------------------------------- Applies a\",\n \"LIMIT {1})\\\"\\\"\\\".format( self.alias, max_cardinality ) if distinct_count > max_cardinality: query\",\n \"vColumn alias. catalog, dict : Catalog of pre-computed aggregations. parent,\",\n \"library with scikit-like functionality for conducting # data science projects\",\n \"\\\"\\\"\\\" --------------------------------------------------------------------------- Multiplies the vColumn by the input element. Parameters\",\n \"= sauv[elem] return self.parent # ---# def geo_plot(self, *args, **kwargs):\",\n \"self.aggregate([\\\"skewness\\\"]).values[self.alias][0] skew = skewness # ---# def slice(self, length: int,\",\n \"the aggregation. max_cardinality: int, optional Maximum number of the vColumn\",\n \") # ---# def str_extract(self, pat: str): \\\"\\\"\\\" --------------------------------------------------------------------------- Extracts\",\n \"return total # ---# def min(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the\",\n \"pass to the geopandas plot function. For more information, see:\",\n \"if \\\"top\\\" in elem: if \\\"percent\\\" in elem: self.catalog[elem] =\",\n \"method = method.lower() self.parent.are_namecols_in(by) by = self.parent.format_colnames(by) nullifzero, n =\",\n \"[\\\"auto\\\", \\\"donut\\\", \\\"rose\\\"]), ] ) donut = True if pie_type\",\n \"the first dummy to avoid the creation of correlated features.\",\n \"descriptive statistics. \\\"\\\"\\\" return self.describe(method=\\\"categorical\\\", max_cardinality=k) # ---# def var(self):\",\n \"Encode]: The vColumn {} was transformed using a mean encoding\",\n \"OVER (), PERCENTILE_CONT(1 - {}) WITHIN GROUP (ORDER BY {})\",\n \"[\\\"ffill\\\", \\\"pad\\\", \\\"bfill\\\", \\\"backfill\\\"]: all_partition += [elem for elem in\",\n \"vColumn. \\\"\\\"\\\" return self.iloc(limit=limit) # ---# def hist( self, method:\",\n \"optional The describe method. auto : Sets the method to\",\n \"try: try: ctype = get_data_types( \\\"SELECT {} AS apply_test_feature FROM\",\n \"'{}')\\\".format( \\\"{}\\\", to_replace.replace(\\\"'\\\", \\\"''\\\"), value.replace(\\\"'\\\", \\\"''\\\") ) ) # ---#\",\n \"partition_by = ( \\\"PARTITION BY {}\\\".format( \\\", \\\".join([quote_ident(column) for column\",\n \"optional The method used for the plot. gaussian : Gaussian\",\n \"vDataFrame self.parent See Also -------- vDataFrame.filter: Filters the data using\",\n \"must be date like (date, datetime, timestamp...) or numerical. by:\",\n \"TS field from the vColumn. \\\"\\\"\\\" check_types( [ (\\\"length\\\", length,\",\n \"to compute other vColumns. Parameters ---------- add_history: bool, optional If\",\n \"least one element to use to order the data\\\" )\",\n \"vDataFrameSQL(query) elif isinstance(index, int): cast = \\\"::float\\\" if self.category() ==\",\n \"# \\\\ / / / # \\\\ / / /\",\n \"an aggregation. vColumns will memorize the already computed aggregations to\",\n \"input aggregations. \\\"\\\"\\\" return self.aggregate([\\\"avg\\\"]).values[self.alias][0] mean = avg # ---#\",\n \"---------- method: str, optional Method to use to normalize. zscore\",\n \"lower) if (isinstance(lower, (float, int))) else \\\"\\\" ) upper_when =\",\n \"the distribution. mean : Average of the vColumn 'of'. min\",\n \"more information, see utilities.tablesample. See Also -------- vDataFrame[].nlargest : Returns\",\n \"a part of the vColumn (delimited by an offset and\",\n \"(SELECT AVG({}) FROM vdf_table WHERE {} < {}) UNION ALL\",\n \"# limitations under the License. # # |_ |~) _\",\n \"vDataFrame The vDataFrame of the search. See Also -------- vDataFrame.isin\",\n \"slicing having steps different than 1.\\\" ) index_stop = index.stop\",\n \"\\\\ \\\\-./\\\\ \\\\ \\\\ \\\\ \\\\-. \\\\ # \\\\ \\\\__|\",\n \"10): \\\"\\\"\\\" --------------------------------------------------------------------------- Computes the Information Value (IV) / Weight\",\n \"on a response column to find the most relevant interval\",\n \"# ---# def max(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using\",\n \"Computes the vDataFrame input aggregations. \\\"\\\"\\\" check_types([(\\\"approx\\\", approx, [bool])]) if\",\n \"try: sauv = {} for elem in self.catalog: sauv[elem] =\",\n \"must be greater or equal to 1\\\") where = \\\"\",\n \"Warning : SQL code generation will be slower if the\",\n \"LIMIT {}) VERTICAPY_SUBTABLE ORDER BY split_value::float\\\".format( \\\" UNION ALL \\\".join(query),\",\n \"for k in range(len(distinct_elements) - n): name = ( '\\\"{}{}\\\"'.format(prefix,\",\n \"\\\\ \\\\ \\\\/\\\\ \\\\ \\\\ \\\\ \\\\____ \\\\ \\\\ \\\\_\\\\\",\n \"(\\\"max_cardinality\\\", max_cardinality, [int, float]), (\\\"numcol\\\", numcol, [str]), ] ) method\",\n \"is date. See Also -------- vDataFrame[].isbool : Returns True if\",\n \"(IV) Table. \\\"\\\"\\\" check_types([(\\\"y\\\", y, [str]), (\\\"nbins\\\", nbins, [int])]) self.parent.are_namecols_in(y)\",\n \"vColumn. \\\"\\\"\\\" check_types([(\\\"n\\\", n, [int, float])]) query = \\\"SELECT *\",\n \"* sauv[\\\"count\\\"] / self.parent.shape()[0] ) except: pass self.parent.__add_to_history__( \\\"[Discretize]: The\",\n \"pass max_floor -= len(self.transformations) if copy_name: self.add_copy(name=copy_name) for k in\",\n \"self.category())] self.transformations += final_transformation sauv = {} for elem in\",\n \"\\\"{}\\\", \\\", \\\".join(by) ) else: new_column = \\\"COALESCE({}, {}({}) OVER\",\n \"== \\\"mean\\\": query = \\\"WITH vdf_table AS (SELECT * FROM\",\n \"i ) for i in range(parameters[\\\"n_estimators\\\"]) ] query = \\\"SELECT\",\n \"if (method in (\\\"ffill\\\", \\\"pad\\\")) else \\\" DESC\\\" partition_by =\",\n \"start_or_end = \\\"START\\\" if (start) else \\\"END\\\" return self.apply( func=\\\"TIME_SLICE({},\",\n \"int vColumn expected store usage. See Also -------- vDataFrame.expected_store_usage :\",\n \"to the vColumn. Parameters ---------- func: str Function to use\",\n \"partitioned by the different vColumn categories. Parameters ---------- response: str\",\n \"{} = '{}'\\\".format( bin_spatial_to_str(self.category(), self.alias), category, ) ) query +=\",\n \"(\\\"prefix_sep\\\", prefix_sep, [str]), (\\\"drop_first\\\", drop_first, [bool]), (\\\"use_numbers_as_suffix\\\", use_numbers_as_suffix, [bool]), ]\",\n \"= \\\"DECODE({}, NULL, 0, 1)\\\" elif method in (\\\"mean\\\", \\\"avg\\\",\",\n \"is lesser than November 1993 the 3rd. end_date: str /\",\n \": Computes bins with the same number of elements. same_width\",\n \"The method to use to aggregate the data. count :\",\n \"vColumn descriptive statistics. \\\"\\\"\\\" check_types([(\\\"k\\\", k, [int, float]), (\\\"dropna\\\", dropna,\",\n \"optional If set to True, the record will be sliced\",\n \"**style_kwds Any optional parameter to pass to the Matplotlib functions.\",\n \"By setting this parameter to False, the function's performance can\",\n \"where the vColumn is missing. Returns ------- vDataFrame self.parent See\",\n \"index) # ---# def __len__(self): return int(self.count()) # ---# def\",\n \"# ---# def kurtosis(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using\",\n \"and their distributions as percents. Parameters ---------- k: int, optional\",\n \"int = 200, xlim: tuple = None, ax=None, **style_kwds, ):\",\n \"= self.topk(k).values[\\\"index\\\"] trans = ( \\\"(CASE WHEN {} IN ({})\",\n \"= \\\"_\\\", drop_first: bool = True, use_numbers_as_suffix: bool = False,\",\n \"than November 1993 the 3rd. end_date: str / date, optional\",\n \"most occurent element. See Also -------- vDataFrame.aggregate : Computes the\",\n \"self.parent.__update_catalog__({\\\"index\\\": index, self.alias: result}) for elem in values: for i\",\n \"[elem for elem in self.transformations] total = self.count() if method\",\n \"!= \\\"VERTICAPY_NOT_PRECOMPUTED\\\": return pre_comp assert self.isnum() or self.isdate(), ParameterError( \\\"numh\",\n \"/ / / # \\\\_______/ / / # ______ /\",\n \"\\\"WHEN {} < {} THEN {} \\\".format(\\\"{}\\\", lower, lower) if\",\n \"self.alias, self.alias, self.parent.__genSQL__(), by[0], ), title=\\\"Computing the different categories to\",\n \"for item in sublist] # ---# def div(self, x: float):\",\n \"self.alias, y, y, self.parent.__genSQL__(), ) query = \\\"SELECT {}, MIN(ord)\",\n \"of elements to display. Returns ------- tablesample An object containing\",\n \"new_name.replace('\\\"', \\\"\\\") assert not (self.parent.is_colname_in(new_name)), NameError( f\\\"A vColumn has already\",\n \"will be picked or computed) ax: Matplotlib axes object, optional\",\n \"Parent of the vColumn. transformations, str : List of the\",\n \"box plot of the vColumn. Parameters ---------- by: str, optional\",\n \"ax Matplotlib axes object See Also -------- vDataFrame.plot : Draws\",\n \"the regular expression matches in each of the vColumn record\",\n \"0.75) AS 'approx_75%', APPROXIMATE_PERCENTILE ({3}{4} USING PARAMETERS percentile = 0.9)\",\n \"ORDER BY ord\\\".format( self.alias, query, ) title = \\\"Computing WOE\",\n \"Aggregates the vColumn using 'mad' (median absolute deviation). Returns -------\",\n \"= [\\\"unique\\\", \\\"count\\\"] + [item[0] for item in query_result] else:\",\n \"0, max_cardinality: int = 8, cat_priority: list = [], ax=None,\",\n \") return [item for sublist in query_result for item in\",\n \"len(breaks) == len(labels) + 1 or not (labels), ParameterError( \\\"Length\",\n \"{}) / {}({} - {})\\\".format( \\\"{}\\\", cmin, \\\"NULLIFZERO\\\" if (nullifzero)\",\n \"Rose chart. It can also be a cutomized aggregation (ex:\",\n \"= {} for elem in self.catalog: sauv[elem] = self.catalog[elem] self.parent.__update_catalog__(erase=True,\",\n \"method == \\\"null\\\": self.apply( func=\\\"(CASE WHEN ({} BETWEEN {} AND\",\n \"Parameters ---------- x: float Input number. Returns ------- vDataFrame self.parent\",\n \"drop_first: bool = True, use_numbers_as_suffix: bool = False, ): \\\"\\\"\\\"\",\n \"the vColumn is missing. Returns ------- vDataFrame self.parent See Also\",\n \"n == 1: pre_comp = self.parent.__get_catalog_value__(self.alias, \\\"top\\\") if pre_comp !=\",\n \"vColumn records. The vColumn will be transformed. Parameters ---------- pat:\",\n \"int = 5): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns the tail of the\",\n \"self.alias, dtype ) ) return self.parent except Exception as e:\",\n \"the vColumn record by an input value. The vColumn will\",\n \"upper) if (isinstance(upper, (float, int))) else \\\"\\\" ) func =\",\n \"# \\\\ / _ __|_. _ _ |_) # \\\\/\",\n \"------- vDataFrame self.parent See Also -------- vDataFrame[].date_part : Extracts a\",\n \"|| ']'\\\".format( \\\"{}\\\", h, h, \\\"{}\\\", h, h, h, floor_end\",\n \"# ---# def memory_usage(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns the vColumn memory\",\n \"---# def store_usage(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns the vColumn expected store\",\n \"mapping:{}\\\".format( self.alias, text_info ) ) return self.parent # ---# def\",\n \"ts, by, start_date, end_date, area, step, ax=ax, **style_kwds, ) #\",\n \"See the License for the specific language governing permissions and\",\n \"Returns ------- float sum See Also -------- vDataFrame.aggregate : Computes\",\n \"was converted to {}.\\\".format( self.alias, dtype ) ) return self.parent\",\n \"\\\"\\\"\\\" check_types( [ (\\\"ts\\\", ts, [str]), (\\\"by\\\", by, [str]), (\\\"start_date\\\",\",\n \"the vColumn with One-Hot Encoding. \\\"\\\"\\\" check_types([(\\\"response\\\", response, [str])]) self.parent.are_namecols_in(response)\",\n \"optional Offset. Returns ------- tablesample An object containing the result.\",\n \"Any optional parameter to pass to the geopandas plot function.\",\n \"to in writing, software # distributed under the License is\",\n \"NULL values will not be considered during the computation. Returns\",\n \"distinct_count > max_cardinality: query += ( \\\"UNION ALL (SELECT 'Others',\",\n \"each of the vColumn records. vDataFrame[].extract : Extracts the regular\",\n \") ] self.parent.__add_to_history__( \\\"[AsType]: The vColumn {} was converted to\",\n \"the lowest element of the list will be included. right:\",\n \"max_cardinality: int/tuple, optional Maximum number of distinct elements for vColumns\",\n \"name, parent=self.parent, transformations=[item for item in self.transformations], catalog=self.catalog, ) setattr(self.parent,\",\n \"apply_test_feature FROM {} WHERE {} IS NOT NULL LIMIT 0\\\".format(\",\n \"len(self.parent[response].transformations) - len( self.transformations ) for k in range(max_floor): self.transformations\",\n \"an independent variable in relation to the dependent variable. Parameters\",\n \"Returns ------- vDataFrame self.parent See Also -------- vDataFrame.case_when : Creates\",\n \"-1 if (self.category() == \\\"int\\\") else \\\"\\\" if (h >\",\n \"maximum depth of 10. response: str, optional Response vColumn when\",\n \"( sys.getsizeof(self) + sys.getsizeof(self.alias) + sys.getsizeof(self.transformations) + sys.getsizeof(self.catalog) ) for\",\n \"the vColumn. If this parameter is equal to 0, an\",\n \"{}\\\".format(limit) else: limit = \\\"\\\" query = \\\"(SELECT {} FROM\",\n \"of the vColumn based on an aggregation. Parameters ---------- method:\",\n \"List of the different categories to consider when drawing the\",\n \"self.parent[columns].to_geopandas(self.alias).plot(*args, **kwargs) # ---# def get_dummies( self, prefix: str =\",\n \"END)\\\" trans = (trans, \\\"varchar\\\", \\\"text\\\") if return_enum_trans: return trans\",\n \"(\\\"method\\\", method, [str]), (\\\"of\\\", of, [str]), (\\\"max_cardinality\\\", max_cardinality, [int, float]),\",\n \"can not be empty in case of discretization using the\",\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,\",\n \"value. The vColumn will be transformed. Parameters ---------- to_replace: str\",\n \"/ NULLIFZERO(SUM(events) OVER ()) AS pt_events FROM ({}) x\\\".format( self.alias,\",\n \"str, optional Slice size unit. For example, it can be\",\n \"'of'. sum : Sum of the vColumn 'of'. q% :\",\n \"**updated_dict(param, style_kwds, idx), ) custom_lines += [ Line2D( [0], [0],\",\n \"(min and max). (x - min) / (max - min)\",\n \"the parameter method is set to 'cat_stats'. Returns ------- tablesample\",\n \"values higher than the upper bound to the upper bound\",\n \"the vColumn using 'product'. Returns ------- float product See Also\",\n \"grouping by elements, please use a method in zscore|minmax\\\" warnings.warn(warning_message,\",\n \"different categories to [0, n - 1] (n being the\",\n \"the nth most occurent element. Parameters ---------- dropna: bool, optional\",\n \"RFmodel_params: dict = {}, response: str = \\\"\\\", return_enum_trans: bool\",\n \"(count distinct) var : variance Other aggregations could work if\",\n \"vColumn will be transformed. Parameters ---------- pat: str regular expression.\",\n \"FROM {}\\\".format( self.alias, self.alias, self.alias, self.alias, self.alias, table ) result\",\n \"compliance with the License. # You may obtain a copy\",\n \"cot : trigonometric cotangent exp : exponential function floor :\",\n \"\\\"regr_avgy\\\": {}, \\\"regr_count\\\": {}, \\\"regr_intercept\\\": {}, \\\"regr_r2\\\": {}, \\\"regr_slope\\\": {},\",\n \"vDataFrame self.parent See Also -------- vDataFrame[].slice : Slices the vColumn\",\n \"- The MAD is null !\\\".format( self.alias ) warnings.warn(warning_message, Warning)\",\n \"0 OR events = 0 THEN 0 ELSE (pt_non_events -\",\n \": Returns True if the vColumn category is date. vDataFrame[].isnum\",\n \"usage (byte) See Also -------- vDataFrame.memory_usage : Returns the vDataFrame\",\n \"of the parent vDataFrame. This parameter is used for testing\",\n \"---------- dropna: bool, optional If set to True, NULL values\",\n \"[str]), (\\\"of\\\", of, [str]), (\\\"max_cardinality\\\", max_cardinality, [int, float]), (\\\"h\\\", h,\",\n \"= \\\"\\\", prefix_sep: str = \\\"_\\\", drop_first: bool = True,\",\n \"built-in analytics and machine learning features. It supports the #\",\n \"If set to True, the Median will be drawn. ax:\",\n \"AS ord, SUM(1 - {}) AS non_events, SUM({}) AS events\",\n \"the slicing. Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].str_contains\",\n \"self.parent.format_colnames(column) columns += [column] if not (\\\"cmap\\\" in kwargs): from\",\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:\",\n \"the vColumn. transformations, str : List of the different transformations.\",\n \"\\\"\\\"\\\" --------------------------------------------------------------------------- Draws the Time Series of the vColumn. Parameters\",\n \": most occurent element percent : percent of non-missing elements\",\n \"'numcol' must be numerical\\\" ) cast = \\\"::int\\\" if (self.parent[numcol].isbool())\",\n \"varchar. same_freq : Computes bins with the same number of\",\n \"= gen_tmp_name(schema=schema, name=\\\"view\\\") tmp_model_name = gen_tmp_name(schema=schema, name=\\\"model\\\") assert nbins >=\",\n \"vColumn based on an aggregation. Parameters ---------- method: str, optional\",\n \"the vColumn most occurent elements. \\\"\\\"\\\" if \\\"agg\\\" not in\",\n \"type must be date like (date, datetime, timestamp...) or numerical.\",\n \"vDataFrame[].apply : Applies a function to the input vColumn. \\\"\\\"\\\"\",\n \"assert not (self.parent.is_colname_in(name)), NameError( f\\\"A vColumn has already the alias\",\n \"== 0: warning_message = \\\"Can not normalize {} using the\",\n \"for the categorical vColumns. bfill : Back Propagation of the\",\n \"[bool]))]) prefix = \\\"approx_\\\" if approx else \\\"\\\" return self.aggregate(func=[prefix\",\n \"by 0 is forbidden !\\\") return self.apply(func=\\\"{} / ({})\\\".format(\\\"{}\\\", x))\",\n \"of discretization using the method 'topk'\\\" ) distinct = self.topk(k).values[\\\"index\\\"]\",\n \"use_numbers_as_suffix: bool = False, ): \\\"\\\"\\\" --------------------------------------------------------------------------- Encodes the vColumn\",\n \"cmax, cmin, self.parent.__genSQL__() ), print_time_sql=False, ) except: cmax, cmin =\",\n \"avg = \\\"DECODE({}, {}, NULL)\\\".format( by[0], \\\", \\\".join( [ \\\"{},\",\n \"'ts' is greater than November 1993 the 3rd. plot_median: bool,\",\n \"the method is 'cat_stats'\\\" ) distinct_count, is_numeric, is_date = (\",\n \"{}) WITHIN GROUP (ORDER BY {}) OVER () FROM {}\",\n \"val} return self.parent.isin(val) # ---# def isnum(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns\",\n \"# ____________ ______ # / __ `\\\\ / / #\",\n \"executeSQL( query=query, title=\\\"Computing the descriptive statistics of {}.\\\".format(self.alias), method=\\\"fetchall\\\", )\",\n \"'{}'.\\\".format(old_name, new_name) ) return parent # ---# def round(self, n:\",\n \"def label_encode(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Encodes the vColumn using a bijection\",\n \"== \\\"smart\\\": schema = verticapy.options[\\\"temp_schema\\\"] if not (schema): schema =\",\n \"each of the vColumn records by an input value. \\\"\\\"\\\"\",\n \"= offset tail.dtype[self.alias] = self.ctype() tail.name = self.alias return tail\",\n \"1e-99) if method.lower() == \\\"sturges\\\": best_h = sturges elif method.lower()\",\n \"assert n >= 1, ParameterError(\\\"Parameter 'n' must be greater or\",\n \").format(self.alias, max_cardinality + 1) query = \\\"WITH vdf_table AS (SELECT\",\n \"method. auto : Sets the method to 'numerical' if the\",\n \"!= None else \\\"NULL\\\", elem[1] if elem[1] != None else\",\n \"\\\"s were \\\" if total > 1 else \\\" was\",\n \"AS 'approx_10%', APPROXIMATE_PERCENTILE ({3}{4} USING PARAMETERS percentile = 0.25) AS\",\n \"), title=title, ) tail.count = self.parent.shape()[0] tail.offset = offset tail.dtype[self.alias]\",\n \"1, len(by) if self.isbool(): warning_message = \\\"Normalize doesn't work on\",\n \"END AS woe, CASE WHEN non_events = 0 OR events\",\n \"input number of digits after the comma. Parameters ---------- n:\",\n \"is distributed on an \\\"AS IS\\\" BASIS, # WITHOUT WARRANTIES\",\n \"impute the missing values. auto : Mean for the numerical\",\n \"result], \\\"count\\\": [int(item[1]) for item in result], \\\"percent\\\": [float(round(item[2], 3))\",\n \"max(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using 'max' (Maximum). Returns\",\n \"breaks[idx], breaks[idx + 1] if right: op1, op2, close_l, close_r\",\n \"Plot of the input vColumns. \\\"\\\"\\\" if isinstance(cat_priority, str) or\",\n \"using the method 'smart'.\\\" ) self.parent.are_namecols_in(response) response = self.parent.format_colnames(response) drop(tmp_view_name,\",\n \"--------------------------------------------------------------------------- Returns the distinct categories of the vColumn. Returns -------\",\n \"\\\\ /\\\\ \\\"-./ \\\\ /\\\\ \\\"-.\\\\ \\\\ # \\\\ \\\\\",\n \"for item in executeSQL( query=query, title=\\\"Computing the average of the\",\n \"vDataFrame[].isdate : Returns True if the vColumn category is date.\",\n \"n) return to_tablesample(query, title=title) # ---# def normalize( self, method:\",\n \"), ) cmax = \\\"DECODE({}, {}, NULL)\\\".format( by[0], \\\", \\\".join(\",\n \"END)\\\".format( \\\"{}\\\", p_alpha, p_1_alpha, \\\"{}\\\" ) ) elif method ==\",\n \"example, it can be 'minute' 'hour'... start: bool, optional If\",\n \"donut : Donut chart. rose : Rose chart. It can\",\n \": Normalization using the Robust Z-Score (median and mad). (x\",\n \"Encoding. vDataFrame[].label_encode : Encodes the vColumn with Label Encoding. vDataFrame[].mean_encode\",\n \"relation to the dependent variable. Parameters ---------- y: str Response\",\n \"discretization using the method 'smart'.\\\" ) self.parent.are_namecols_in(response) response = self.parent.format_colnames(response)\",\n \"func.replace(\\\"{}\\\", \\\"x\\\"), ) ) return self.parent except Exception as e:\",\n \"str : List of the different transformations. \\\"\\\"\\\" # #\",\n \"\\\"apply_test_feature\\\", ) except: ctype = get_data_types( \\\"SELECT {} AS apply_test_feature\",\n \"(category in (\\\"None\\\", None)) else \\\" WHERE {} = '{}'\\\".format(\",\n \"= std # ---# def store_usage(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns the\",\n \"= 6, nbins: int = 0, h: float = 0,\",\n \"numcol, cast, ) tmp_query += ( \\\" WHERE {} IS\",\n \"vDataFrame \\\"heavier\\\" if it is used to compute other vColumns.\",\n \"vColumn. The function variable must be composed of two flower\",\n \"from the vDataFrame.\\\".format(self.alias) ) return parent # ---# def drop_outliers(\",\n \"\\\"store_usage\\\") if pre_comp != \\\"VERTICAPY_NOT_PRECOMPUTED\\\": return pre_comp store_usage = executeSQL(\",\n \"p_alpha, self.alias, self.alias, p_1_alpha, ) mean_alpha, mean_1_alpha = [ item[0]\",\n \"\\\" DESC OFFSET {1}) VERTICAPY_SUBTABLE) ORDER BY count DESC\\\" ).format(self.alias,\",\n \"1], [1, 0]) or self.isbool(): all_new_features = [] prefix =\",\n \"[str])]) try: try: ctype = get_data_types( \\\"SELECT {} AS apply_test_feature\",\n \"pass to the Matplotlib functions. Returns ------- ax Matplotlib axes\",\n \"method: str, optional Method to use to fill the vColumn\",\n \"+ desc for column in order_by]) new_column = \\\"COALESCE({}, LAST_VALUE({}\",\n \"vColumn \\\" \\\"or simply because of ambiguous columns naming.\\\\nBy changing\",\n \"element. Parameters ---------- x: float Input number. Returns ------- vDataFrame\",\n \"True): \\\"\\\"\\\" --------------------------------------------------------------------------- Drops the vColumn from the vDataFrame. Dropping\",\n \"the input element. Parameters ---------- x: float Input number. Returns\",\n \"[int, float]), (\\\"h\\\", h, [int, float]), (\\\"nbins\\\", nbins, [int, float]),\",\n \"= self.parent.search( \\\"{} = '{}'\\\".format(self.parent[by].alias, column) )[self.alias].density( bandwidth=bandwidth, kernel=kernel, nbins=nbins,\",\n \"self.isdate(), ) if (is_date) and not (method == \\\"categorical\\\"): result\",\n \"import gen_colors from matplotlib.lines import Line2D colors = gen_colors() if\",\n \"the pie chart of the vColumn based on an aggregation.\",\n \"def normalize( self, method: str = \\\"zscore\\\", by: list =\",\n \"1e-99, ) fd = max(2.0 * (vColumn_075 - vColumn_025) /\",\n \": skewness sum : sum std : standard deviation topk\",\n \"argv[2 * i + 1] ... END odd : CASE\",\n \"and (method != \\\"numerical\\\")) or not (is_numeric) or (method ==\",\n \"((is_date) and not (method == \\\"categorical\\\")) or ( method ==\",\n \"threshold: float, optional Uses the Gaussian distribution to define the\",\n \"sem See Also -------- vDataFrame.aggregate : Computes the vDataFrame input\",\n \"List of the vColumns to use to sort the data\",\n \"ax=None, **style_kwds, ) # ---# def plot( self, ts: str,\",\n \"or equal to 1\\\") where = \\\" WHERE {} IS\",\n \"cat_stats : Computes statistics of a numerical column for each\",\n \"determine if the vColumn will be considered as categorical. numcol:\",\n \"Bar Chart of the input vColumns based on an aggregation.\",\n \"https://geopandas.readthedocs.io/en/latest/docs/reference/api/ geopandas.GeoDataFrame.plot.html Returns ------- ax Matplotlib axes object \\\"\\\"\\\" columns\",\n \"\\\"{}\\\", cmin, \\\"NULLIFZERO\\\" if (nullifzero) else \\\"\\\", cmax, cmin, ),\",\n \"float If the vColumn type is date like (date, datetime\",\n \"Applies functions to the input vColumns. vDataFrame.applymap : Applies a\",\n \"= \\\"SELECT {} FROM (SELECT {} AS {}, {} AS\",\n \"make the vDataFrame \\\"heavier\\\" if it is used to compute\",\n \"import * from verticapy.toolbox import * from verticapy.errors import *\",\n \"self.alias) except: self.parent._VERTICAPY_VARIABLES_[\\\"exclude_columns\\\"] += [self.alias] if add_history: self.parent.__add_to_history__( \\\"[Drop]: vColumn\",\n \"* COUNT({1}) / {2} AS percent, AVG({3}{4}) AS mean, STDDEV({3}{4})\",\n \"kurtosis See Also -------- vDataFrame.aggregate : Computes the vDataFrame input\",\n \"def mode(self, dropna: bool = False, n: int = 1):\",\n \"Aggregates the vColumn using multiple statistical aggregations: min, max, median,\",\n \"The method used for the plot. gaussian : Gaussian kernel.\",\n \"if isinstance(func, str_sql): func = str(func) check_types([(\\\"func\\\", func, [str]), (\\\"copy_name\\\",\",\n \"the vColumn. Parameters ---------- func: str Function to use to\",\n \"an aggregation. Parameters ---------- method: str, optional The method to\",\n \"\\\"\\\"\\\" check_types( [ (\\\"alpha\\\", alpha, [int, float]), (\\\"use_threshold\\\", use_threshold, [bool]),\",\n \"the 3rd. plot_median: bool, optional If set to True, the\",\n \"+= [ (\\\"AVG({}) OVER (PARTITION BY {})\\\".format(response, \\\"{}\\\"), \\\"int\\\", \\\"float\\\")\",\n \"+ [self.max()] elif method == \\\"topk\\\": assert k >= 2,\",\n \"= {} ): self.parent, self.alias, self.transformations = ( parent, alias,\",\n \"by: str = \\\"\\\", start_date: Union[str, datetime.datetime, datetime.date] = \\\"\\\",\",\n \"the vColumns categories. Returns ------- vDataFrame self.parent See Also --------\",\n \"\\\"MEDIAN\\\": val = self.median() new_column = \\\"COALESCE({}, {})\\\".format(\\\"{}\\\", val) elif\",\n \"also be a cutomized aggregation (ex: AVG(column1) + 5). of:\",\n \"= method.lower() assert (method != \\\"cat_stats\\\") or (numcol), ParameterError( \\\"The\",\n \"category in cat: tmp_query = \\\"\\\"\\\"SELECT '{0}' AS 'index', COUNT({1})\",\n \"category, ) ) query += [lp + tmp_query + rp]\",\n \"using 'sem' (standard error of mean). Returns ------- float sem\",\n \"**style_kwds) # ---# def category(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns the category\",\n \"str Function to use to transform the vColumn. abs :\",\n \"self.alias, self.alias, ) else: query = \\\"SELECT {} FROM (SELECT\",\n \"the mode) topk_percent : kth most occurent element density unique\",\n \"2.\\\" ) assert len(breaks) == len(labels) + 1 or not\",\n \"BY {})\\\".format( self.alias, \\\", \\\".join(by) ), ) if return_trans: return\",\n \"response is numerical (except ints and bools), a RF Classifier\",\n \"result = executeSQL( \\\"SELECT {}, MIN({}), MAX({}) FROM {} GROUP\",\n \"by, [str]), (\\\"start_date\\\", start_date, [str, datetime.datetime, datetime.date]), (\\\"end_date\\\", end_date, [str,\",\n \"= self.median() new_column = \\\"COALESCE({}, {})\\\".format(\\\"{}\\\", val) elif (len(by) ==\",\n \"nbins: int = 10): \\\"\\\"\\\" --------------------------------------------------------------------------- Computes the Information Value\",\n \"------- vDataFrame self.parent See Also -------- vDataFrame.astype : Converts the\",\n \"/ date, optional Input Start Date. For example, time =\",\n \"vColumn. method: dict, optional Method to use to impute the\",\n \"if (use_numbers_as_suffix) else '\\\"{}{}\\\"'.format( prefix, str(distinct_elements[k]).replace('\\\"', \\\"_\\\") ) ) assert\",\n \"IS\\\" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,\",\n \"categorical variables.\\\" ) warnings.warn(warning_message, Warning) else: distinct_elements = self.distinct() expr\",\n \"the result of using previously the method on the vColumn\",\n \"1], result[i] ) trans += \\\" ELSE NULL END)\\\" trans\",\n \"avg(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using 'avg' (Average). Returns\",\n \"self.aggregate([\\\"min\\\", \\\"max\\\"]).values[self.alias] if cmax - cmin == 0: warning_message =\",\n \"\\\\ \\\\_\\\\\\\\\\\"\\\\_\\\\ # \\\\/_/ \\\\/_____/ \\\\/_____/ \\\\/_____/ \\\\/_____/ \\\\/_/ \\\\/_/\",\n \"n = 1, len(by) if self.isbool(): warning_message = \\\"Normalize doesn't\",\n \"was transformed using a mean encoding with {} as Response\",\n \"FROM {} LIMIT 1\\\".format( avg, stddev, self.parent.__genSQL__() ), print_time_sql=False, )\",\n \"Logistic kernel. sigmoid : Sigmoid kernel. silverman : Silverman kernel.\",\n \"\\\"logistic\\\", \\\"sigmoid\\\", \\\"silverman\\\"]), (\\\"bandwidth\\\", bandwidth, [int, float]), (\\\"nbins\\\", nbins, [float,\",\n \") else: for k in range(max_floor): self.transformations += [(\\\"{}\\\", self.ctype(),\",\n \"cast = \\\"::float\\\" if self.category() == \\\"float\\\" else \\\"\\\" if\",\n \"the different aggregations.\\\", method=\\\"fetchall\\\", ) for idx, elem in enumerate(result):\",\n \"(ex: 50% for the median) prod : product range :\",\n \"converted to {}\\\".format( e, self.alias, dtype ) ) # ---#\",\n \"be one of the following: date / int / float\",\n \"+= [ Line2D( [0], [0], color=updated_dict(param, style_kwds, idx)[\\\"color\\\"], lw=4, ),\",\n \"self.parent.are_namecols_in(of) of = self.parent.format_colnames(of) from verticapy.plot import hist return hist(self,\",\n \"DOY / EPOCH / HOUR / ISODOW / ISOWEEK /\",\n \"\\\"null\\\": self.apply( func=\\\"(CASE WHEN ({} BETWEEN {} AND {}) THEN\",\n \"method: str = \\\"auto\\\", expr: str = \\\"\\\", by: list\",\n \"and the values higher than the upper bound to the\",\n \"top = float(top) self.parent.__update_catalog__( {\\\"index\\\": [\\\"top{}\\\".format(n)], self.alias: [top]} ) return\",\n \"IS NOT NULL ORDER BY {} ASC LIMIT {}\\\".format( self.parent.__genSQL__(),\",\n \"decrease. Returns ------- float/str median See Also -------- vDataFrame.aggregate :\",\n \": Converts the vColumns to the input type. \\\"\\\"\\\" check_types([(\\\"dtype\\\",\",\n \"range_curve_vdf return range_curve_vdf( self, ts, q, start_date, end_date, plot_median, ax=ax,\",\n \"only valid if the vColumns are numerical. Optimized h will\",\n \"AS count\\\" \\\" FROM vdf_table WHERE {0} IS NOT NULL\",\n \") elif method in (\\\"ffill\\\", \\\"pad\\\", \\\"bfill\\\", \\\"backfill\\\"): assert order_by,\",\n \"y: str Response vColumn. nbins: int, optional Maximum number of\",\n \"expression. Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].str_count :\",\n \") method = method.lower() if method == \\\"auto\\\": pre_comp =\",\n \"if elem[0] != None else \\\"NULL\\\", elem[1] if elem[1] !=\",\n \"check_types( [ (\\\"by\\\", by, [str]), (\\\"method\\\", method, [str]), (\\\"of\\\", of,\",\n \"column in by]) ) if (by) else \\\"\\\" ) order_by_ts\",\n \"\\\"unique\\\", \\\"count\\\", \\\"mean\\\", \\\"std\\\", \\\"min\\\", \\\"approx_25%\\\", \\\"approx_50%\\\", \\\"approx_75%\\\", \\\"max\\\", ]\",\n \"See Also -------- vDataFrame.case_when : Creates a new feature by\",\n \") if (is_date) and not (method == \\\"categorical\\\"): result =\",\n \"def fillna( self, val=None, method: str = \\\"auto\\\", expr: str\",\n \"kurtosis jb : Jarque-Bera index mad : median absolute deviation\",\n \"{}\\\".format( self.alias, self.alias, self.alias, self.parent.__genSQL__(), self.alias, where, ) result =\",\n \"elem[2] != None else \\\"NULL\\\", ) for elem in result\",\n \"--------------------------------------------------------------------------- Draws the Time Series of the vColumn. Parameters ----------\",\n \"the vColumn distinct elements to be used as categorical (No\",\n \"threshold: float, optional Uses the Gaussian distribution to identify outliers.\",\n \"), (\\\"x\\\", x, [int, float]), ] ) if func not\",\n \"Returns ------- vDataFrame self.parent See Also -------- vDataFrame.outliers : Computes\",\n \"alias: str vColumn alias. transformations: list, optional List of the\",\n \"(n == 1) and (self.parent[by[0]].nunique() < 50): try: result =\",\n \"to use to compute the aggregation. max_cardinality: int, optional Maximum\",\n \"to_tablesample(query, title=title) result.values[\\\"index\\\"] += [\\\"total\\\"] result.values[\\\"non_events\\\"] += [sum(result[\\\"non_events\\\"])] result.values[\\\"events\\\"] +=\",\n \"{} {} missing value{} filled.\\\".format( total, self.alias, conj, ) )\",\n \"0]) or self.isbool(): all_new_features = [] prefix = ( self.alias.replace('\\\"',\",\n \"bandwidth=bandwidth, kernel=kernel, nbins=nbins, xlim=(xmin, xmax), ax=ax, **updated_dict(param, style_kwds, idx), )\",\n \"vDataFrame expected store usage. \\\"\\\"\\\" pre_comp = self.parent.__get_catalog_value__(self.alias, \\\"store_usage\\\") if\",\n \"column = self.parent.format_colnames(column) columns += [column] if not (\\\"cmap\\\" in\",\n \"math, re, decimal, warnings, datetime from collections.abc import Iterable from\",\n \"aggregations: min, max, median, unique... depending on the input method.\",\n \"# \\\\/ # _ # \\\\ / _ __|_. _\",\n \"ints and bools), a RF Classifier otherwise. Example: Write {\\\"n_estimators\\\":\",\n \"new_vColumn) setattr(self.parent, name[1:-1], new_vColumn) self.parent._VERTICAPY_VARIABLES_[\\\"columns\\\"] += [name] self.parent.__add_to_history__( \\\"[Add Copy]:\",\n \"be able to look at the final transformation. Returns -------\",\n \"= ( self.parent.describe( method=\\\"numerical\\\", columns=[self.alias], unique=False ) .transpose() .values[self.alias] )\",\n \"self.catalog[\\\"count\\\"] = self.parent.shape()[0] self.catalog[\\\"percent\\\"] = 100 self.parent.__add_to_history__( \\\"[Label Encoding]: Label\",\n \"{} WHERE {} IS NOT NULL LIMIT 0\\\".format( func.replace(\\\"{}\\\", self.alias),\",\n \"= None if not (result) else result[0][0] if not (dropna):\",\n \"0.25 represents Q1. approx: bool, optional If set to True,\",\n \"of the response partitioned by the different vColumn categories. Parameters\",\n \"the vColumn using 'count' (Number of non-Missing elements). Returns -------\",\n \"the method 'topk'\\\" ) distinct = self.topk(k).values[\\\"index\\\"] trans = (\",\n \"\\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using 'sum'. Returns ------- float\",\n \"be picked or computed) h: float, optional Interval width of\",\n \") self.parent[y].distinct() trans = self.discretize( method=\\\"same_width\\\" if self.isnum() else \\\"topk\\\",\",\n \"arithmetic sign sin : trigonometric sine sinh : hyperbolic sine\",\n \": Encodes the vColumn with One-Hot Encoding. vDataFrame[].mean_encode : Encodes\",\n \") if (by) else \\\"\\\" ) order_by_ts = \\\", \\\".join([quote_ident(column)\",\n \"self.apply(func=func) return self.parent # ---# def count(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates\",\n \"k, [int, float]), (\\\"dropna\\\", dropna, [bool])]) topk = \\\"\\\" if\",\n \"KIND, either express or implied. # See the License for\",\n \"so it's better practice to use this method when first\",\n \"Draws the pie chart of the vColumn based on an\",\n \"\\\"NULLIFZERO\\\" if (nullifzero) else \\\"\\\", stddev ), \\\"float\\\", \\\"float\\\", )\",\n \"using 'max' (Maximum). Returns ------- float/str maximum See Also --------\",\n \"datetime.date, int, float], ), (\\\"plot_median\\\", plot_median, [bool]), ] ) self.parent.are_namecols_in(ts)\",\n \"= \\\"WITH vdf_table AS (SELECT * FROM {}) (SELECT AVG({})\",\n \"in order_by]) new_column = \\\"COALESCE({}, LAST_VALUE({} IGNORE NULLS) OVER ({}\",\n \"occurent element). 0ifnull : 0 when the vColumn is null,\",\n \"self.parent.__get_last_order_by__(), index, ) return executeSQL( query=query, title=\\\"Getting the vColumn element.\\\",\",\n \") distinct_count, is_numeric, is_date = ( self.nunique(), self.isnum(), self.isdate(), )\",\n \"float Input number. Returns ------- vDataFrame self.parent See Also --------\",\n \"vColumn. Returns ------- str/float/int vColumn nth most occurent element. See\",\n \"is part of the DB version you are using. Returns\",\n \"[ (\\\"prefix\\\", prefix, [str]), (\\\"prefix_sep\\\", prefix_sep, [str]), (\\\"drop_first\\\", drop_first, [bool]),\",\n \"float]), (\\\"response\\\", response, [str]), (\\\"nbins\\\", nbins, [int, float]), ( \\\"method\\\",\",\n \"absolute deviation max : maximum mean : average median :\",\n \"After normalizing the data (Z-Score), if the absolute value of\",\n \": Parent of the vColumn. transformations, str : List of\",\n \"None else \\\"NULL\\\", elem[1] if elem[1] != None else \\\"NULL\\\",\",\n \"int]), ] ) if by: self.parent.are_namecols_in(by) by = self.parent.format_colnames(by) columns\",\n \"Modules import math, re, decimal, warnings, datetime from collections.abc import\",\n \"encoding with {} as Response Column.\\\".format( self.alias, response ) )\",\n \"self.alias return tail # ---# def isbool(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns\",\n \"self.alias, result[\\\"avg\\\"][0], result[\\\"std\\\"][0], threshold ) ) else: p_alpha, p_1_alpha =\",\n \": Uses only categorical aggregations during the computation. cat_stats :\",\n \"very useful for testing to be able to look at\",\n \"if len(all_new_features) > 1 else \\\" was \\\" self.parent.__add_to_history__( \\\"[Get\",\n \"compute the best splits when 'method' is set to 'smart'.\",\n \"the data\\\" ) desc = \\\"\\\" if (method in (\\\"ffill\\\",\",\n \"ax Matplotlib axes object See Also -------- vDataFrame[].hist : Draws\",\n \"trans = ( \\\"'[' || FLOOR({} / {}) * {}\",\n \"a time series rule. Parameters ---------- length: int Slice size.\",\n \"a ‘pipeline’ mechanism to sequentialize # data transformation operations, and\",\n \"{} as Response Column.\\\".format( self.alias, response ) ) if verticapy.options[\\\"print_info\\\"]:\",\n \"self.describe(method=\\\"categorical\\\", max_cardinality=k) # ---# def var(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the\",\n \"= 0 self.catalog[\\\"mad\\\"] = 1 / 1.4826 elif method ==\",\n \"to return. dropna: bool, optional If set to True, NULL\",\n \"to 'smart'. return_enum_trans: bool, optional Returns the transformation instead of\",\n \"# # Unless required by applicable law or agreed to\",\n \"in (\\\"same_width\\\", \\\"auto\\\"): if not (h) or h <= 0:\",\n \"Rounds the vColumn by keeping only the input number of\",\n \"{}, MIN({}), MAX({}) FROM {} GROUP BY {}\\\".format( by[0], self.alias,\",\n \"] ), ) cmax = \\\"DECODE({}, {}, NULL)\\\".format( by[0], \\\",\",\n \"[lp + tmp_query + rp] query = \\\"WITH vdf_table AS\",\n \"\\\"float\\\", \\\"float\\\" elif method == \\\"0ifnull\\\": category, ctype = \\\"int\\\",\",\n \"pass elif math.isnan(result[i][2]): result[i][2] = None avg = \\\"DECODE({}, {},\",\n \"value{} filled.\\\".format( total, self.alias, conj, ) ) else: if verticapy.options[\\\"print_info\\\"]:\",\n \"partition the data. h: float, optional Interval width if the\",\n \"\\\"(SELECT {} FROM {}{} OFFSET {}{}) VERTICAPY_SUBTABLE\\\".format( self.alias, self.parent.__genSQL__(), self.parent.__get_last_order_by__(),\",\n \": Drops the vColumn missing values. \\\"\\\"\\\" if isinstance(by, str):\",\n \"not (schema): schema = \\\"public\\\" name = gen_tmp_name(schema=schema, name=\\\"kde\\\") if\",\n \"warnings.warn(warning_message, Warning) return self elif (n == 1) and (self.parent[by[0]].nunique()\",\n \"using the input expression. \\\"\\\"\\\" self.parent.filter(\\\"{} IS NOT NULL\\\".format(self.alias)) return\",\n \"BY {})\\\".format(response, \\\"{}\\\"), \\\"int\\\", \\\"float\\\") ] self.parent.__update_catalog__(erase=True, columns=[self.alias]) self.parent.__add_to_history__( \\\"[Mean\",\n \"List of the different records. For example, to check if\",\n \"if isinstance(cat_priority, str) or not (isinstance(cat_priority, Iterable)): cat_priority = [cat_priority]\",\n \"VERTICAPY_SUBTABLE\\\".format( self.alias, self.parent.__genSQL__(), self.parent.__get_last_order_by__(), index_start, limit, ) return vDataFrameSQL(query) elif\",\n \"import bar return bar(self, method, of, max_cardinality, nbins, h, ax=ax,\",\n \"import sys total = ( sys.getsizeof(self) + sys.getsizeof(self.alias) + sys.getsizeof(self.transformations)\",\n \"case of discretization using the method 'smart'.\\\" ) assert response,\",\n \"OVER (PARTITION BY {})\\\".format( self.alias, \\\", \\\".join(by) ), ) if\",\n \"sliced using the floor of the slicing instead of the\",\n \"(SELECT * FROM {}) {}\\\".format( self.parent.__genSQL__(), \\\" UNION ALL \\\".join(query)\",\n \"Also -------- vDataFrame[].decode : Encodes the vColumn with user defined\",\n \"a vColumn can make the vDataFrame \\\"heavier\\\" if it is\",\n \"as an outlier. use_threshold: bool, optional Uses the threshold instead\",\n \"list, optional vColumns used in the partition. return_trans: bool, optimal\",\n \"def __nonzero__(self): return self.count() > 0 # ---# def __repr__(self):\",\n \"occurent element percent : percent of non-missing elements q% :\",\n \"- min) / (max - min) by: list, optional vColumns\",\n \"start_date, [str, datetime.datetime, datetime.date, int, float], ), ( \\\"end_date\\\", end_date,\",\n \"= model.fit(self.parent.__genSQL__(), [self.alias]).plot( ax=ax, **style_kwds ) model.drop() return result except:\",\n \"THEN 0 ELSE (pt_non_events - pt_events) * ZEROIFNULL(LN(pt_non_events / NULLIFZERO(pt_events)))\",\n \"self.count()] + [item[1] for item in query_result] index = [\\\"unique\\\",\",\n \"is used to compute other vColumns. Parameters ---------- add_history: bool,\",\n \"input vColumn. \\\"\\\"\\\" check_types([(\\\"x\\\", x, [int, float])]) return self.apply(func=\\\"{} *\",\n \"the vDataFrame input aggregations. \\\"\\\"\\\" return self.aggregate([\\\"stddev\\\"]).values[self.alias][0] stddev = std\",\n \"\\\"index\\\": [item[0] for item in result], \\\"count\\\": [int(item[1]) for item\",\n \"RandomForestClassifier, RandomForestRegressor, ) drop(tmp_model_name, method=\\\"model\\\") if self.parent[response].category() == \\\"float\\\": model\",\n \"in kwargs: query = \\\"SELECT {} AS {} FROM {}\",\n \"was added to the vDataFrame.\\\".format( self.alias, name ) ) return\",\n \"import Iterable from typing import Union # VerticaPy Modules import\",\n \"APPROXIMATE_PERCENTILE({} USING PARAMETERS percentile = 0.75) AS Q3, MAX({}) AS\",\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 (\",\n \"unit: str = \\\"second\\\", start: bool = True): \\\"\\\"\\\" ---------------------------------------------------------------------------\",\n \"approx_unique : approximative cardinality count : number of non-missing elements\",\n \"if (self.parent[numcol].isbool()) else \\\"\\\" query, cat = [], self.distinct() if\",\n \"model = RandomForestClassifier(tmp_model_name) model.set_params({\\\"n_estimators\\\": 20, \\\"max_depth\\\": 8, \\\"nbins\\\": 100}) model.set_params(RFmodel_params)\",\n \"/ ISOWEEK / ISOYEAR / MICROSECONDS / MILLENNIUM / MILLISECONDS\",\n \"the vDataFrame where the vColumn is missing. Returns ------- vDataFrame\",\n \"= self.parent[by].distinct() for idx, column in enumerate(columns): param = {\\\"color\\\":\",\n \"h: float = 0, nbins: int = -1, k: int\",\n \"category)] self.parent[copy_name].catalog = self.catalog self.parent.__add_to_history__( \\\"[Apply]: The vColumn '{}' was\",\n \"len(labels) + 1 or not (labels), ParameterError( \\\"Length of parameter\",\n \"Returns the distinct categories of the vColumn. Returns ------- list\",\n \"= self.count() if method not in [\\\"mode\\\", \\\"0ifnull\\\"]: max_floor =\",\n \"a cutomized aggregation (ex: AVG(column1) + 5). of: str, optional\",\n \"Also -------- vDataFrame[].tail : Returns the a part of the\",\n \"NULL \\\".format(self.alias) if (dropna) else \\\" \\\" result = executeSQL(\",\n \"lower=None, upper=None): \\\"\\\"\\\" --------------------------------------------------------------------------- Clips the vColumn by transforming the\",\n \"(/_| | |(_(_|| \\\\/ # / # VerticaPy is a\",\n \"self.transformations[-1][2] # ---# def clip(self, lower=None, upper=None): \\\"\\\"\\\" --------------------------------------------------------------------------- Clips\",\n \"parameter 'breaks' must be greater or equal to 2.\\\" )\",\n \"to use a mean encoding\\\" ) max_floor = len(self.parent[response].transformations) -\",\n \"result = [distinct_count, self.count()] + [item[1] for item in query_result]\",\n \"of, [str]), (\\\"max_cardinality\\\", max_cardinality, [list]), (\\\"h\\\", h, [list, float, int]),\",\n \"(SELECT split_value, MAX(weighted_information_gain) FROM ({}) VERTICAPY_SUBTABLE WHERE split_value IS NOT\",\n \"AS max FROM {}\\\".format( self.alias, self.alias, self.alias, self.alias, self.alias, table\",\n \"in kwargs: column = kwargs[\\\"column\\\"] else: check = False if\",\n \"(method == \\\"categorical\\\") ): query = \\\"\\\"\\\"(SELECT {0} || '',\",\n \"method=\\\"view\\\") drop(tmp_model_name, method=\\\"model\\\") result = [self.min()] + result + [self.max()]\",\n \"the vColumn. Parameters ---------- ts: str TS (Time Series) vColumn\",\n \"\\\\ \\\\_____\\\\ \\\\ \\\\_____\\\\ \\\\ \\\\_____\\\\ \\\\ \\\\_\\\\ \\\\ \\\\_\\\\\",\n \"result}) for elem in values: for i in range(len(values[elem])): if\",\n \"function to the input vColumn. \\\"\\\"\\\" return self.apply(func=\\\"ABS({})\\\") # ---#\",\n \"time series. \\\"\\\"\\\" check_types( [ (\\\"ts\\\", ts, [str]), (\\\"q\\\", q,\",\n \"(\\\"bandwidth\\\", bandwidth, [int, float]), (\\\"nbins\\\", nbins, [float, int]), ] )\",\n \"try: if \\\"count\\\" in sauv: self.catalog[\\\"count\\\"] = sauv[\\\"count\\\"] self.catalog[\\\"percent\\\"] =\",\n \"\\\"SELECT {}, AVG({}), STDDEV({}) FROM {} GROUP BY {}\\\".format( by[0],\",\n \"otherwise. categorical : Uses only categorical aggregations during the computation.\",\n \"VerticaPy aims to do all of the above. The idea\",\n \"transformations=transformations, catalog={ \\\"min\\\": 0, \\\"max\\\": 1, \\\"count\\\": self.parent.shape()[0], \\\"percent\\\": 100.0,\",\n \"are in the vDataFrame. \\\"\\\"\\\" if isinstance(val, str) or not\",\n \"{}. For example to apply the function: x -> x^2\",\n \"return self.apply(func=\\\"TIMESTAMPADD(SECOND, -({}), {})\\\".format(x, \\\"{}\\\")) else: return self.apply(func=\\\"{} - ({})\\\".format(\\\"{}\\\",\",\n \"cardinality count : number of non-missing elements cvar : conditional\",\n \"set to True, draw an Area Plot. step: bool, optional\",\n \"query=query, title=\\\"Computing the descriptive statistics of {}.\\\".format(self.alias), method=\\\"fetchall\\\", ) result\",\n \"raised to the power of another number round : rounds\",\n \"to get the median). It can also be a cutomized\",\n \"have multiple children vColumns whereas one vColumn can only have\",\n \"must be a vDataFrame column if the method is 'cat_stats'\\\"\",\n \"lower and upper ZScores. threshold: float, optional Uses the Gaussian\",\n \"optional Method to use to compute the optimal h. auto\",\n \"{} was renamed '{}'.\\\".format(old_name, new_name) ) return parent # ---#\",\n \"\\\"\\\" return self.aggregate(func=[prefix + \\\"{}%\\\".format(x * 100)]).values[self.alias][ 0 ] #\",\n \"vColumn elements. \\\"\\\"\\\" check_types([(\\\"n\\\", n, [int, float])]) query = \\\"SELECT\",\n \"computation. cat_stats : Computes statistics of a numerical column for\",\n \"normalize. zscore : Normalization using the Z-Score (avg and std).\",\n \"Methods # # ---# def __init__( self, alias: str, transformations:\",\n \"new_vColumn = vColumn( name, parent=self.parent, transformations=[item for item in self.transformations],\",\n \"return self elif n == 1: try: result = executeSQL(\",\n \"2, \\\"approx_unique\\\": 2, \\\"prod\\\": 0, }, ) setattr(self.parent, name, new_vColumn)\",\n \"quantile). See Also -------- vDataFrame.aggregate : Computes the vDataFrame input\",\n \"Extracts a specific TS field from the vColumn. \\\"\\\"\\\" check_types(\",\n \"self.parent.describe( method=\\\"numerical\\\", columns=[self.alias], unique=False ) .transpose() .values[self.alias] ) result =\",\n \"to use to aggregate the data. count : Number of\",\n \"*args, **kwargs): \\\"\\\"\\\" --------------------------------------------------------------------------- Draws the Geospatial object. Parameters ----------\",\n \"self.catalog[elem] = (sauv[elem] - sauv[\\\"mean\\\"]) / sauv[ \\\"std\\\" ] elif\",\n \"data. The vColumn type must be date like (date, datetime,\",\n \"self.parent, self.alias, self.transformations = ( parent, alias, [elem for elem\",\n \"\\\"robust_zscore\\\": if n > 0: warning_message = \\\"The method 'robust_zscore'\",\n \"\\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using 'count' (Number of non-Missing\",\n \"the vColumn. vDataFrame[].tail : Returns the tail of the vColumn.\",\n \"--------------------------------------------------------------------------- Aggregates the vColumn using 'count' (Number of non-Missing elements).\",\n \"------- str vColumn category. See Also -------- vDataFrame[].ctype : Returns\",\n \"\\\"Normalize doesn't work on booleans\\\".format(self.alias) warnings.warn(warning_message, Warning) elif self.isnum(): if\",\n \"= \\\"Can not normalize {} using a Robust Z-Score -\",\n \"list of at least one element to use to order\",\n \"the Random Forest model parameters used to compute the best\",\n \"str): \\\"\\\"\\\" --------------------------------------------------------------------------- Converts the vColumn to the input type.\",\n \"encoding. vDataFrame[].discretize : Discretizes the vColumn. vDataFrame[].label_encode : Encodes the\",\n \"approximative cardinality count : number of non-missing elements cvar :\",\n \"--------------------------------------------------------------------------- Converts the vColumn to the input type. Parameters ----------\",\n \"ORDER BY count DESC\\\" ).format(self.alias, max_cardinality + 1) query =\",\n \"= index_stop - index_start if limit <= 0: limit =\",\n \"def numh(self, method: str = \\\"auto\\\"): \\\"\\\"\\\" --------------------------------------------------------------------------- Computes the\",\n \"discretization using the method 'smart'.\\\" ) assert response, ParameterError( \\\"Parameter\",\n \"of \\\" \\\"the parameters ('prefix', 'prefix_sep'), you'll be able to\",\n \"method. RFmodel_params: dict, optional Dictionary of the Random Forest model\",\n \"== 1: try: result = executeSQL( \\\"SELECT {}, MIN({}), MAX({})\",\n \"fd = max(2.0 * (vColumn_075 - vColumn_025) / (count) **\",\n \"or equal to 2.\\\" ) assert len(breaks) == len(labels) +\",\n \"Also -------- vDataFrame[].describe : Computes the vColumn descriptive statistics. \\\"\\\"\\\"\",\n \"\\\\ \\\\ \\\\____ \\\\ \\\\ \\\\_\\\\ \\\\ \\\\ \\\\ \\\\-./\\\\\",\n \"cardinality (count distinct) var : variance Other aggregations could work\",\n \"/ # _____________ / / # \\\\ / / /\",\n \"-------- vDataFrame[].apply : Applies a function to the input vColumn.\",\n \"of: self.parent.are_namecols_in(of) of = self.parent.format_colnames(of) from verticapy.plot import pie return\",\n \"Donut chart. rose : Rose chart. It can also be\",\n \"20 trees and a maximum depth of 10. response: str,\",\n \"in copy_trans] for elem in sauv: self.catalog[elem] = sauv[elem] return\",\n \"\\\"NULL\\\" if (elem[1] == None) else str(elem[1]) new_column = \\\"COALESCE({},\",\n \"MILLENNIUM / MILLISECONDS / MINUTE / MONTH / QUARTER /\",\n \"self.parent.__update_catalog__( {\\\"index\\\": [\\\"store_usage\\\"], self.alias: [store_usage]} ) return store_usage # ---#\",\n \"threshold, it will be considered as an outlier. use_threshold: bool,\",\n \"Silverman kernel. nbins: int, optional Maximum number of points to\",\n \"---------- x: float If the vColumn type is date like\",\n \"input aggregations. \\\"\\\"\\\" check_types([(\\\"approx\\\", approx, [bool])]) if approx: return self.aggregate(func=[\\\"approx_unique\\\"]).values[self.alias][0]\",\n \"ORDER BY {}\\\".format( bin_spatial_to_str(self.category(), self.alias), self.alias, self.parent.__genSQL__(), self.alias, self.alias, self.alias,\",\n \"deleted from the vDataFrame.\\\".format(self.alias) ) return parent # ---# def\",\n \"n > 0: warning_message = \\\"The method 'robust_zscore' is available\",\n \"and method == \\\"same_freq\\\") or ( self.isnum() and method ==\",\n \"# ---# def abs(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Applies the absolute value\",\n \"WOE & IV of {} (response = {}).\\\".format(self.alias, y) result\",\n \"vColumn_075, vColumn_max = result sturges = max( float(vColumn_max - vColumn_min)\",\n \"vDataFrame self.parent See Also -------- vDataFrame.outliers : Computes the vDataFrame\",\n \"= self.aggregate([\\\"min\\\", \\\"max\\\"]).values[self.alias] if cmax - cmin == 0: warning_message\",\n \"self.catalog[elem] = None elif method == \\\"robust_zscore\\\": self.catalog[elem] = (sauv[elem]\",\n \"str): by = [by] check_types( [ (\\\"method\\\", method, [\\\"zscore\\\", \\\"robust_zscore\\\",\",\n \"bins.\\\", method=\\\"fetchall\\\", ) result = [elem[0] for elem in result]\",\n \"\\\"\\\"\\\" --------------------------------------------------------------------------- Renames the vColumn by dropping the current vColumn\",\n \"optional Prefix delimitor of the dummies. drop_first: bool, optional Drops\",\n \"in kwargs): from verticapy.plot import gen_cmap kwargs[\\\"cmap\\\"] = gen_cmap()[0] else:\",\n \"int, optional Number of bins. If empty, an optimized number\",\n \"new_name) ) return parent # ---# def round(self, n: int):\",\n \"(n being the vColumn cardinality). Returns ------- vDataFrame self.parent See\",\n \"------- vDataFrame self.parent See Also -------- vDataFrame.case_when : Creates a\",\n \"or ( method == \\\"is_numeric\\\" ): self.parent.__update_catalog__({\\\"index\\\": index, self.alias: result})\",\n \"on the input method. Parameters ---------- method: str, optional The\",\n \"math.isnan(result[i][2]): result[i][2] = None avg = \\\"DECODE({}, {}, NULL)\\\".format( by[0],\",\n \"---------- alias, str : vColumn alias. catalog, dict : Catalog\",\n \"self.parent.aggregate(func=func, columns=[self.alias]).transpose() agg = aggregate # ---# def apply(self, func:\",\n \"\\\".join([quote_ident(column) for column in by]) ) if (by) else \\\"\\\"\",\n \"\\\"SELECT {} AS index, non_events, events, pt_non_events, pt_events, CASE WHEN\",\n \"warnings.warn(warning_message, Warning) return self.parent if isinstance(val, str): val = val.replace(\\\"'\\\",\",\n \"or self.isdate(), TypeError( \\\"cut only works on numerical / date-like\",\n \"\\\"\\\"\\\" columns = [self.alias] check = True if len(args) >\",\n \"\\\"\\\" for category in cat: tmp_query = \\\"\\\"\\\"SELECT '{0}' AS\",\n \"object. Parameters ---------- *args / **kwargs Any optional parameter to\",\n \"vColumn to the input type. Parameters ---------- dtype: str New\",\n \"vColumn. \\\"\\\"\\\" check_types([(\\\"x\\\", x, [int, float])]) if self.isdate(): return self.apply(func=\\\"TIMESTAMPADD(SECOND,\",\n \"WHERE {} IS NOT NULL ORDER BY {} DESC LIMIT\",\n \"step: bool = False, ax=None, **style_kwds, ): \\\"\\\"\\\" --------------------------------------------------------------------------- Draws\",\n \"ts, q, start_date, end_date, plot_median, ax=ax, **style_kwds, ) # ---#\",\n \"vColumn. abs : absolute value acos : trigonometric inverse cosine\",\n \"result.values[\\\"index\\\"] += [\\\"total\\\"] result.values[\\\"non_events\\\"] += [sum(result[\\\"non_events\\\"])] result.values[\\\"events\\\"] += [sum(result[\\\"events\\\"])] result.values[\\\"pt_non_events\\\"]\",\n \"date like (date, datetime ...), the parameter 'x' will represent\",\n \"() FROM {} LIMIT 1\\\".format( alpha, self.alias, alpha, self.alias, self.parent.__genSQL__()\",\n \"vDataFrame column if the method is 'cat_stats'\\\" ) distinct_count, is_numeric,\",\n \"= ( \\\"NULL\\\" if (elem[0] == None) else \\\"'{}'\\\".format(str(elem[0]).replace(\\\"'\\\", \\\"''\\\"))\",\n \"= \\\"\\\", return_enum_trans: bool = False, ): \\\"\\\"\\\" --------------------------------------------------------------------------- Discretizes\",\n \"median( self, approx: bool = True, ): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates\",\n \"/ int(math.floor(math.log(count, 2) + 2)), 1e-99, ) fd = max(2.0\",\n \"old_name = quote_ident(self.alias) new_name = new_name.replace('\\\"', \\\"\\\") assert not (self.parent.is_colname_in(new_name)),\",\n \"\\\"min\\\", \\\"approx_25%\\\", \\\"approx_50%\\\", \\\"approx_75%\\\", \\\"max\\\", ] if method != \\\"cat_stats\\\":\",\n \"a function to the vColumn. Parameters ---------- func: str, Function\",\n \"in result], \\\"count\\\": [int(item[1]) for item in result], \\\"percent\\\": [float(round(item[2],\",\n \"-threshold * result[\\\"std\\\"][0] + result[\\\"avg\\\"][0], threshold * result[\\\"std\\\"][0] + result[\\\"avg\\\"][0],\",\n \"\\\"MEDIAN\\\" if (method == \\\"median\\\") else \\\"AVG\\\" if by ==\",\n \"if pie_type == \\\"donut\\\" else False rose = True if\",\n \") cmax = \\\"DECODE({}, {}, NULL)\\\".format( by[0], \\\", \\\".join( [\",\n \"self.parent except Exception as e: raise ConversionError( \\\"{}\\\\nThe vColumn {}\",\n \"AVG({}) FROM vdf_table WHERE {} > {})\\\".format( self.parent.__genSQL__(), self.alias, self.alias,\",\n \"available for categorical variables.\\\" ) warnings.warn(warning_message, Warning) else: distinct_elements =\",\n \"For example, if n = 1 then this method will\",\n \"transformed. Parameters ---------- pat: str Regular expression. Returns ------- vDataFrame\",\n \"step, [int, float])]) return self.apply(func=\\\"SUBSTR({}, {}, {})\\\".format(\\\"{}\\\", start, step)) #\",\n \"(nullifzero) else \\\"\\\", stddev ) else: final_transformation = [ (\",\n \"Tuple including the 2 quantiles used to draw the Plot.\",\n \"a method in zscore|minmax\\\" warnings.warn(warning_message, Warning) return self mad, med\",\n \"while total < int(float(count / int(nbins))) * int(nbins): nth_elems +=\",\n \"to [0, n - 1] (n being the vColumn cardinality).\",\n \"for elem in sauv: if \\\"top\\\" in elem: if \\\"percent\\\"\",\n \"product range : difference between the max and the min\",\n \"The type of pie chart. auto : Regular pie chart.\",\n \"\\\"mod\\\", \\\"pow\\\", \\\"round\\\", \\\"sign\\\", \\\"sin\\\", \\\"sinh\\\", \\\"sqrt\\\", \\\"tan\\\", \\\"tanh\\\", ],\",\n \"the vDataFrame input aggregations. \\\"\\\"\\\" return self.aggregate(func=[\\\"prod\\\"]).values[self.alias][0] prod = product\",\n \"cut the vColumn. labels: list, optional Labels used to name\",\n \"END)\\\".format( \\\"{}\\\", p_alpha, mean_alpha, \\\"{}\\\", p_1_alpha, mean_1_alpha, \\\"{}\\\" ) )\",\n \"vColumn is numerical, False otherwise. Returns ------- bool True if\",\n \"bin_spatial_to_str(self.category()), new_category.replace(\\\"'\\\", \\\"''\\\"), ), \\\"varchar\\\", \\\"text\\\", ) elif self.isnum() and\",\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\",\n \"(Maximum). Returns ------- float/str maximum See Also -------- vDataFrame.aggregate :\",\n \"+ 2 use \\\"POWER({}, 2) + 2\\\". copy_name: str, optional\",\n \"or ( re.search( re.compile(\\\"\\\\\\\\b{}\\\\\\\\b\\\".format(column.replace('\\\"', \\\"\\\"))), func ) ): max_floor =\",\n \"{} || '' ELSE '{}' END)\\\".format( bin_spatial_to_str(self.category()), \\\", \\\".join( [\",\n \"if by: self.parent.are_namecols_in(by) by = self.parent.format_colnames(by) from verticapy.plot import ts_plot\",\n \"the vColumn (delimited by an offset and a limit). Parameters\",\n \"optional Number of elements to display. offset: int, optional Number\",\n \"\\\"auto\\\"])] ) method = method.lower() if method == \\\"auto\\\": pre_comp\",\n \"aggregation (ex: AVG(column1) + 5). ax: Matplotlib axes object, optional\",\n \"start, [int, float]), (\\\"step\\\", step, [int, float])]) return self.apply(func=\\\"SUBSTR({}, {},\",\n \"Average. median : median. mode : mode (most occurent element).\",\n \"= \\\"::float\\\" if self.category() == \\\"float\\\" else \\\"\\\" if index\",\n \"\\\"int\\\")] new_vColumn = vColumn( name, parent=self.parent, transformations=transformations, catalog={ \\\"min\\\": 0,\",\n \"elem in by: if len(self.parent[elem].transformations) > max_floor: max_floor = len(self.parent[elem].transformations)\",\n \"useful for testing to be able to look at the\",\n \"if (self.isnum() and method == \\\"same_freq\\\") or ( self.isnum() and\",\n \"down to the next whole number ln : natural logarithm\",\n \"trans = \\\"(CASE \\\" for i in range(1, n): trans\",\n \"} if ((is_date) and not (method == \\\"categorical\\\")) or (\",\n \"[list]), ] ) method = method.lower() self.parent.are_namecols_in([elem for elem in\",\n \"the discretization (must be > 1) k: int, optional The\",\n \"intervals should be closed. If set to True, the intervals\",\n \"--------------------------------------------------------------------------- Discretizes the vColumn using the input method. Parameters ----------\",\n \"in self.catalog: sauv[elem] = self.catalog[elem] self.parent.__update_catalog__(erase=True, columns=[self.alias]) total = abs(self.count()\",\n \"should be closed. If set to True, the intervals will\",\n \"USING PARAMETERS percentile = 0.1) AS 'approx_10%', APPROXIMATE_PERCENTILE ({3}{4} USING\",\n \"the vColumn. vDataFrame[].str_slice : Slices the vColumn. \\\"\\\"\\\" check_types([(\\\"to_replace\\\", to_replace,\",\n \"assert nbins >= 2, ParameterError( \\\"Parameter 'nbins' must be greater\",\n \"list. Parameters ---------- breaks: list List of values used to\",\n \"expression. \\\"\\\"\\\" check_types([(\\\"name\\\", name, [str])]) name = quote_ident(name.replace('\\\"', \\\"_\\\")) assert\",\n \"# ---# def fillna( self, val=None, method: str = \\\"auto\\\",\",\n \"def str_count(self, pat: str): \\\"\\\"\\\" --------------------------------------------------------------------------- Computes the number of\",\n \"Method to use to compute the optimal h. auto :\",\n \"self.aggregate([\\\"stddev\\\"]).values[self.alias][0] stddev = std # ---# def store_usage(self): \\\"\\\"\\\" ---------------------------------------------------------------------------\",\n \"pure SQL used to transform the vColumn. The function variable\",\n \"and it returns the new vDataFrame of the search. Parameters\",\n \"axes object See Also -------- vDataFrame.bar : Draws the Bar\",\n \"h will be computed. pie_type: str, optional The type of\",\n \"else \\\"NULL\\\", ) for elem in result if elem[2] !=\",\n \"for column in self.parent._VERTICAPY_VARIABLES_[\\\"columns\\\"] ] force_columns.remove(self.alias) executeSQL( \\\"SELECT * FROM\",\n \"not be empty in case of discretization using the method\",\n \"work on booleans\\\".format(self.alias) warnings.warn(warning_message, Warning) elif self.isnum(): if method ==\",\n \"vDataFrame, optional Parent of the vColumn. One vDataFrame can have\",\n \"then this method will return the mode of the vColumn.\",\n \"try: result = model.fit(self.parent.__genSQL__(), [self.alias]).plot( ax=ax, **style_kwds ) model.drop() return\",\n \"most frequent categories and merge the other into one unique\",\n \"\\\"[\\\" elif idx == 0: op1, close_l = \\\"<\\\", \\\"]\\\"\",\n \"computed) nbins: int, optional Number of bins. If empty, an\",\n \"func = \\\"(CASE {}{}ELSE {} END)\\\".format(lower_when, upper_when, \\\"{}\\\") self.apply(func=func) return\",\n \"{}\\\".format( self.parent.__genSQL__(), \\\" UNION ALL \\\".join(query) ) title = \\\"Describes\",\n \"alpha: float, optional Number representing the outliers threshold. Values lesser\",\n \"as categorical (No h will be picked or computed) h:\",\n \"statistics. \\\"\\\"\\\" check_types([(\\\"k\\\", k, [int, float]), (\\\"dropna\\\", dropna, [bool])]) topk\",\n \"to True, the Median will be drawn. ax: Matplotlib axes\",\n \"\\\"SELECT {} FROM {} LIMIT 1\\\".format( new_column.format(self.alias), self.parent.__genSQL__() ), print_time_sql=False,\",\n \"\\\"\\\" query = \\\"(SELECT {} FROM {}{} OFFSET {}{}) VERTICAPY_SUBTABLE\\\".format(\",\n \"= abs(self.count() - total) except Exception as e: self.transformations =\",\n \"self.mode(dropna=True) if val == None: warning_message = \\\"The vColumn {}\",\n \"\\\"\\\", bandwidth: float = 1.0, kernel: str = \\\"gaussian\\\", nbins:\",\n \"IS NOT NULL GROUP BY {} ORDER BY {}\\\".format( bin_spatial_to_str(self.category(),\",\n \"supports the # entire data science life cycle, uses a\",\n \"(date, datetime, timestamp...) or numerical. by: str, optional vColumn to\",\n \"__ __ __ __ # /\\\\ \\\\ / / /\\\\\",\n \"(\\\"alpha\\\", alpha, [int, float]), (\\\"use_threshold\\\", use_threshold, [bool]), (\\\"threshold\\\", threshold, [int,\",\n \"= self.parent.format_colnames(of) from verticapy.plot import bar return bar(self, method, of,\",\n \"columns=[self.alias], unique=False ) .transpose() .values[self.alias] ) count, vColumn_min, vColumn_025, vColumn_075,\",\n \"---# def isnum(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns True if the vColumn\",\n \"expr) elif method == \\\"0ifnull\\\": new_column = \\\"DECODE({}, NULL, 0,\",\n \"the func 'x -> {}'.\\\".format( self.alias.replace('\\\"', \\\"\\\"), func.replace(\\\"{}\\\", \\\"x\\\"), )\",\n \"if the vColumn is numerical. \\\"\\\"\\\" return self.ctype().lower() in (\\\"bool\\\",\",\n \"= method.lower() check_types( [ (\\\"method\\\", method, [\\\"winsorize\\\", \\\"null\\\", \\\"mean\\\"]), (\\\"alpha\\\",\",\n \"# # Standard Python Modules import math, re, decimal, warnings,\",\n \"(\\\"freedman_diaconis\\\", \\\"fd\\\"): best_h = fd else: best_h = max(sturges, fd)\",\n \"result.values[\\\"pt_events\\\"] += [\\\"\\\"] result.values[\\\"woe\\\"] += [\\\"\\\"] result.values[\\\"iv\\\"] += [sum(result[\\\"iv\\\"])] return\",\n \"self.alias, query, ) query = \\\"SELECT {} AS index, non_events,\",\n \"h, [int, float]), (\\\"pie_type\\\", pie_type, [\\\"auto\\\", \\\"donut\\\", \\\"rose\\\"]), ] )\",\n \"NULL)\\\".format( by[0], \\\", \\\".join( [ \\\"{}, {}\\\".format( \\\"'{}'\\\".format(str(elem[0]).replace(\\\"'\\\", \\\"''\\\")) if\",\n \"\\\"SELECT {}{} FROM {}{} OFFSET {} LIMIT 1\\\".format( self.alias, cast,\",\n \"log10 : base 10 logarithm mod : remainder of a\",\n \"# VerticaPy Modules import verticapy from verticapy.utilities import * from\",\n \"Percentage of the distribution. mean : Average of the vColumn\",\n \"kwargs[\\\"figsize\\\"] = (14, 10) return self.parent[columns].to_geopandas(self.alias).plot(*args, **kwargs) # ---# def\",\n \"for i in range(len(values[elem])): if isinstance(values[elem][i], decimal.Decimal): values[elem][i] = float(values[elem][i])\",\n \"datetime.datetime, datetime.date] = \\\"\\\", end_date: Union[str, datetime.datetime, datetime.date] = \\\"\\\",\",\n \"use to evaluate the approximate density function. Increasing this parameter\",\n \"boxplot( self, by: str = \\\"\\\", h: float = 0,\",\n \"Start Date. For example, time = '03-11-1993' will filter the\",\n \"the n largest vColumn elements. \\\"\\\"\\\" check_types([(\\\"n\\\", n, [int, float])])\",\n \"[list]), (\\\"return_trans\\\", return_trans, [bool]), ] ) method = method.lower() self.parent.are_namecols_in(by)\",\n \"method=\\\"fetchfirstelem\\\", ) else: return getattr(self, index) # ---# def __len__(self):\",\n \"h: float = 0, ax=None, **style_kwds, ): \\\"\\\"\\\" --------------------------------------------------------------------------- Draws\",\n \"isinstance(method, str): method = method.lower() check_types( [ (\\\"method\\\", method, [\\\"winsorize\\\",\",\n \"(result) else result[0][0] if not (dropna): n = \\\"\\\" if\",\n \"BY _verticapy_cnt_ DESC LIMIT {}) VERTICAPY_SUBTABLE ORDER BY _verticapy_cnt_ ASC\",\n \"else: label = f\\\"{close_l}{first_elem};{second_elem}{close_r}\\\" conditions += [ f\\\"'{first_elem}' {op1} {column}\",\n \"by]) ) if (by) else \\\"\\\" ) order_by_ts = \\\",\",\n \"and creating a copy with the specified name. \\\\u26A0 Warning\",\n \"return vDataFrameSQL(query) elif isinstance(index, int): cast = \\\"::float\\\" if self.category()\",\n \"Slices the vColumn. \\\"\\\"\\\" check_types([(\\\"pat\\\", pat, [str])]) return self.apply( func=\\\"REGEXP_COUNT({},\",\n \"> max_cardinality: query += ( \\\"UNION ALL (SELECT 'Others', SUM(count)\",\n \"WHEN \\\".join(conditions) + \\\" END\\\" self.apply(func=expr) # ---# def ctype(self):\",\n \") except: new_column = \\\"COALESCE({}, {}({}) OVER (PARTITION BY {}))\\\".format(\",\n \"Aggregates the vColumn using 'median'. Parameters ---------- approx: bool, optional\",\n \"{}\\\".format( bin_spatial_to_str(self.category(), self.alias), self.alias, self.parent.shape()[0], self.parent.__genSQL__(), dropna, self.alias, topk, )\",\n \"events, non_events / NULLIFZERO(SUM(non_events) OVER ()) AS pt_non_events, events /\",\n \"100 * COUNT({1}) / {2} AS percent, AVG({3}{4}) AS mean,\",\n \"date, optional Input End Date. For example, time = '03-11-1993'\",\n \"50% for the median) prod : product range : difference\",\n \"{}, \\\"regr_slope\\\": {}, \\\"regr_sxx\\\": {}, \\\"regr_sxy\\\": {}, \\\"regr_syy\\\": {}, }\",\n \"expression. by: list, optional vColumns used in the partition. order_by:\",\n \"= MIN !\\\".format( self.alias ) warnings.warn(warning_message, Warning) return self elif\",\n \"0 is forbidden !\\\") return self.apply(func=\\\"{} / ({})\\\".format(\\\"{}\\\", x)) #\",\n \"of = self.parent.format_colnames(of) from verticapy.plot import hist return hist(self, method,\",\n \"= 0 self.catalog[\\\"max\\\"] = 1 self.parent.__add_to_history__( \\\"[Normalize]: The vColumn '{}'\",\n \"self.count() nb = int(float(count / int(nbins))) assert nb != 0,\",\n \"by[0], fun, self.alias, self.parent.__genSQL__(), by[0] ) result = executeSQL( query,\",\n \"optional If set to True, draw an Area Plot. step:\",\n \"pat: str regular expression. Returns ------- vDataFrame self.parent See Also\",\n \"transformations. Each transformation must be similar to the following: (function,\",\n \"\\\"\\\"\\\" --------------------------------------------------------------------------- Encodes the vColumn using a bijection from the\",\n \"float]), (\\\"numcol\\\", numcol, [str]), ] ) method = method.lower() assert\",\n \"NULL GROUP BY 1 ORDER BY 2 DESC LIMIT {})\",\n \"is null, 1 otherwise. expr: str, optional SQL expression. by:\",\n \"__ __ # /\\\\ \\\\ / / /\\\\ ___\\\\ /\\\\\",\n \"\\\"END\\\" return self.apply( func=\\\"TIME_SLICE({}, {}, '{}', '{}')\\\".format( \\\"{}\\\", length, unit.upper(),\",\n \"able to solve this \\\" \\\"issue.\\\" ) for k in\",\n \"__ __ __ __ __ # /\\\\ \\\\ / /\",\n \"\\\"boolean\\\") # ---# def isdate(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns True if\",\n \"{} IS NOT NULL) VERTICAPY_SUBTABLE {}\\\".format( self.alias, self.alias, self.alias, self.parent.__genSQL__(),\",\n \"category, ctype = \\\"float\\\", \\\"float\\\" elif method == \\\"0ifnull\\\": category,\",\n \"check_types([(\\\"k\\\", k, [int, float]), (\\\"dropna\\\", dropna, [bool])]) topk = \\\"\\\"\",\n \"**kwargs): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns the distinct categories of the vColumn.\",\n \"------- float kurtosis See Also -------- vDataFrame.aggregate : Computes the\",\n \") result = executeSQL( query, title=\\\"Computing the different aggregations.\\\", method=\\\"fetchall\\\",\",\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,\",\n \"\\\"cbrt\\\", \\\"ceil\\\", \\\"cos\\\", \\\"cosh\\\", \\\"cot\\\", \\\"exp\\\", \\\"floor\\\", \\\"ln\\\", \\\"log\\\", \\\"log10\\\",\",\n \"\\\"<\\\", \\\"]\\\" if labels: label = labels[idx] else: label =\",\n \"WHERE {} IS NOT NULL) VERTICAPY_SUBTABLE {}\\\".format( self.alias, self.alias, self.alias,\",\n \"= [elem for elem in copy_trans] raise QueryError(\\\"{}\\\\nAn Error happened\",\n \"elif method == \\\"robust_zscore\\\": self.catalog[elem] = (sauv[elem] - sauv[\\\"approx_50%\\\"]) /\",\n \"[str]), (\\\"q\\\", q, [tuple]), ( \\\"start_date\\\", start_date, [str, datetime.datetime, datetime.date,\",\n \"* 1.01 / nbins if h > 0.01: h =\",\n \"\\\\-. \\\\ # \\\\ \\\\__| \\\\ \\\\_____\\\\ \\\\ \\\\_____\\\\ \\\\\",\n \"h will be computed. ax: Matplotlib axes object, optional The\",\n \"columns=[self.alias]) try: if \\\"count\\\" in sauv: self.catalog[\\\"count\\\"] = sauv[\\\"count\\\"] self.catalog[\\\"percent\\\"]\",\n \"= 0, nbins: int = -1, k: int = 6,\",\n \"\\\"int\\\") else \\\"\\\" if (h > 1) or (self.category() ==\",\n \"True, use_numbers_as_suffix: bool = False, ): \\\"\\\"\\\" --------------------------------------------------------------------------- Encodes the\",\n \"self.parent.format_colnames(by) from verticapy.plot import boxplot return boxplot(self, by, h, max_cardinality,\",\n \"number of seconds, otherwise it will represent a number. Returns\",\n \"drop_first else 0 for k in range(len(distinct_elements) - n): name\",\n \"\\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using 'max' (Maximum). Returns -------\",\n \"method: str = \\\"zscore\\\", by: list = [], return_trans: bool\",\n \"--------------------------------------------------------------------------- Renames the vColumn by dropping the current vColumn and\",\n \"the vColumn. vDataFrame[].str_replace : Replaces the regular expression matches in\",\n \"column = [], self.alias for idx in range(len(breaks) - 1):\",\n \"name.replace('\\\"', \\\"\\\"), EmptyParameter( \\\"The parameter 'name' must not be empty\\\"\",\n \"could work if it is part of the DB version\",\n \"NULLIFZERO(pt_events))) END AS iv FROM ({}) x ORDER BY ord\\\".format(\",\n \"---------- k: int, optional Number of most occurent elements to\",\n \"{}\\\".format( by[0], self.alias, self.alias, self.parent.__genSQL__(), by[0], ), title=\\\"Computing the different\",\n \"= by if method in [\\\"ffill\\\", \\\"pad\\\", \\\"bfill\\\", \\\"backfill\\\"]: all_partition\",\n \"{}::{} AS {} FROM {} WHERE {} IS NOT NULL\",\n \"the vColumn. \\\"\\\"\\\" check_types([(\\\"to_replace\\\", to_replace, [str]), (\\\"value\\\", value, [str])]) return\",\n \"is numerical (except ints and bools), a RF Classifier otherwise.\",\n \"response partitioned by the different vColumn categories. Parameters ---------- response:\",\n \"title = \\\"Describes the statics of {} partitioned by {}.\\\".format(\",\n \"matches for the regular expression in each record of the\",\n \"values[elem][i] = float(values[elem][i]) return tablesample(values) # ---# def discretize( self,\",\n \"class vColumn(str_sql): \\\"\\\"\\\" --------------------------------------------------------------------------- Python object which that stores all\",\n \"column 'numcol' must be numerical\\\" ) cast = \\\"::int\\\" if\",\n \"text_info += \\\"\\\\t{} => {}\\\".format(distinct_elements[k], k) expr = \\\", \\\".join(expr)\",\n \"**style_kwds, ): \\\"\\\"\\\" --------------------------------------------------------------------------- Draws the bar chart of the\",\n \"information, see utilities.tablesample. See Also -------- vDataFrame[].describe : Computes the\",\n \"return self.parent # ---# def fill_outliers( self, method: str =\",\n \"return self.parent except Exception as e: raise ConversionError( \\\"{}\\\\nThe vColumn\",\n \"object See Also -------- vDataFrame.plot : Draws the time series.\",\n \"(\\\"dropna\\\", dropna, [bool])]) topk = \\\"\\\" if (k < 1)\",\n \"vColumn with One-Hot Encoding. \\\"\\\"\\\" check_types([(\\\"response\\\", response, [str])]) self.parent.are_namecols_in(response) response\",\n \"November 1993 the 3rd. end_date: str / date, optional Input\",\n \"the method 'same_freq'\\\" ) count = self.count() nb = int(float(count\",\n \"ELSE NULL END)\\\" trans = (trans, \\\"varchar\\\", \\\"text\\\") if return_enum_trans:\",\n \"computation. n: int, optional Integer corresponding to the offset. For\",\n \"is set to 'smart'. A RF Regressor will be trained\",\n \"from verticapy.toolbox import * from verticapy.errors import * ## #\",\n \"list = [], return_trans: bool = False ): \\\"\\\"\\\" ---------------------------------------------------------------------------\",\n \"= [], parent=None, catalog: dict = {} ): self.parent, self.alias,\",\n \"{} has no mode (only missing values).\\\\nNothing was filled.\\\".format( self.alias\",\n \") return top # ---# def mul(self, x: float): \\\"\\\"\\\"\",\n \"catalog: self.catalog[elem] = catalog[elem] # ---# def __getitem__(self, index): if\",\n \"---# def avg(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using 'avg'\",\n \"\\\"auto\\\", ax=None, **style_kwds, ): \\\"\\\"\\\" --------------------------------------------------------------------------- Draws the pie chart\",\n \"MIN(ord) AS ord, SUM(1 - {}) AS non_events, SUM({}) AS\",\n \"title=\\\"Computing the mode.\\\", method=\\\"fetchall\\\", ) top = None if not\",\n \"nb, [], [] while total < int(float(count / int(nbins))) *\",\n \"= \\\"CASE WHEN \\\" + \\\" WHEN \\\".join(conditions) + \\\"\",\n \"the vColumn using 'skewness'. Returns ------- float skewness See Also\",\n \"of non-Missing elements. See Also -------- vDataFrame.aggregate : Computes the\",\n \"\\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using 'median'. Parameters ---------- approx:\",\n \"store usage. \\\"\\\"\\\" pre_comp = self.parent.__get_catalog_value__(self.alias, \\\"store_usage\\\") if pre_comp !=\",\n \") trans += \\\" ELSE NULL END)\\\" trans = (trans,\",\n \"{}.\\\".format(self.alias), method=\\\"fetchrow\\\", ) if method == \\\"winsorize\\\": self.clip(lower=p_alpha, upper=p_1_alpha) elif\",\n \"self.alias, text_info ) ) return self.parent # ---# def mad(self):\",\n \"vDataFrame is modified. Attributes ---------- alias, str : vColumn alias.\",\n \"median : median. mode : mode (most occurent element). 0ifnull\",\n \"to use iv_woe.\\\".format(y) ) self.parent[y].distinct() trans = self.discretize( method=\\\"same_width\\\" if\",\n \"transformations], ) self.catalog = { \\\"cov\\\": {}, \\\"pearson\\\": {}, \\\"spearman\\\":\",\n \"self.isnum() and method in (\\\"same_width\\\", \\\"auto\\\"): if not (h) or\",\n \"\\\"The parameter 'name' must not be empty\\\" ) assert not\",\n \"\\\\/_/ # # # ---# class vColumn(str_sql): \\\"\\\"\\\" --------------------------------------------------------------------------- Python\",\n \"'{}'\\\".format(self.parent[by].alias, column) )[self.alias].density( bandwidth=bandwidth, kernel=kernel, nbins=nbins, xlim=(xmin, xmax), ax=ax, **updated_dict(param,\",\n \"if (h > 1) or (self.category() == \\\"float\\\"): trans =\",\n \"\\\"\\\", end_date: Union[str, datetime.datetime, datetime.date] = \\\"\\\", plot_median: bool =\",\n \"upper ZScores. threshold: float, optional Uses the Gaussian distribution to\",\n \"self, method: str = \\\"density\\\", of: str = \\\"\\\", max_cardinality:\",\n \"by[0] ) result = executeSQL( query, title=\\\"Computing the different aggregations.\\\",\",\n \"BY ord\\\".format( self.alias, query, ) title = \\\"Computing WOE &\",\n \"enumerate(columns): param = {\\\"color\\\": colors[idx % len(colors)]} ax = self.parent.search(\",\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\",\n \"warning_message = \\\"Normalize doesn't work on booleans\\\".format(self.alias) warnings.warn(warning_message, Warning) elif\",\n \"op1, close_l = \\\"<=\\\", \\\"[\\\" elif idx == 0: op1,\",\n \"at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable\",\n \"for the specific language governing permissions and # limitations under\",\n \"bool = True, ): \\\"\\\"\\\" --------------------------------------------------------------------------- Discretizes the vColumn using\",\n \"or (method == \\\"categorical\\\") ): query = \\\"\\\"\\\"(SELECT {0} ||\",\n \"Keeps the topk most frequent categories and merge the other\",\n \"if isinstance(values[elem][i], decimal.Decimal): values[elem][i] = float(values[elem][i]) return tablesample(values) # ---#\",\n \"= executeSQL( query, title=\\\"Computing the top{} categories of {}.\\\".format( k\",\n \"+ 1] ... END odd : CASE ... WHEN vColumn\",\n \"user transformations. If the vDataFrame represents the entire relation, a\",\n \"FROM {}) (SELECT AVG({}) FROM vdf_table WHERE {} < {})\",\n \"the approximate density function. Increasing this parameter will increase the\",\n \"k >= 2, ParameterError( \\\"Parameter 'k' must be greater or\",\n \"labels: list = [], include_lowest: bool = True, right: bool\",\n \"mean_1_alpha = [ item[0] for item in executeSQL( query=query, title=\\\"Computing\",\n \"language governing permissions and # limitations under the License. #\",\n \"not (h) or h <= 0: if nbins <= 0:\",\n \"\\\"\\\", end_date: Union[str, datetime.datetime, datetime.date] = \\\"\\\", area: bool =\",\n \"n, [int, float])]) if n == 1: pre_comp = self.parent.__get_catalog_value__(self.alias,\",\n \"Slices the vColumn. \\\"\\\"\\\" check_types([(\\\"to_replace\\\", to_replace, [str]), (\\\"value\\\", value, [str])])\",\n \"- cmin == 0: warning_message = \\\"Can not normalize {}\",\n \"trigonometric inverse sine atan : trigonometric inverse tangent cbrt :\",\n \"max_cardinality: int = 6, nbins: int = 0, h: float\",\n \"November 1993 the 3rd. area: bool, optional If set to\",\n \"on data stored in Vertica, taking advantage Vertica’s # speed\",\n \"= gen_colors()[0] if not (\\\"legend\\\" in kwargs): kwargs[\\\"legend\\\"] = True\",\n \"to pass to the Matplotlib functions. Returns ------- ax Matplotlib\",\n \"h will be picked or computed) nbins: int, optional Number\",\n \"\\\\/\\\\ \\\\ \\\\ \\\\ \\\\____ \\\\ \\\\ \\\\_\\\\ \\\\ \\\\\",\n \"the head of the vColumn. Parameters ---------- limit: int, optional\",\n \"{} AS ord, {}::int AS {} FROM {}\\\".format( trans, self.alias,\",\n \"method.lower() self.parent.are_namecols_in(by) by = self.parent.format_colnames(by) nullifzero, n = 1, len(by)\",\n \"be numerical for Normalization\\\") return self.parent # ---# def nsmallest(self,\",\n \"ts: str TS (Time Series) vColumn to use to order\",\n \"q quantile (ex: 50% for the median) prod : product\",\n \"the vColumn. Parameters ---------- limit: int, optional Number of elements\",\n \"k: int = 6, new_category: str = \\\"Others\\\", RFmodel_params: dict\",\n \"OVER (ORDER BY {}) AS _verticapy_row_nb_ FROM {} WHERE {}\",\n \"to 1\\\") where = \\\" WHERE {} IS NOT NULL\",\n \"\\\"avg\\\", \\\"median\\\", \\\"ffill\\\", \\\"pad\\\", \\\"bfill\\\", \\\"backfill\\\", ], ), (\\\"expr\\\", expr,\",\n \"\\\" result = executeSQL( \\\"SELECT {} FROM (SELECT {}, COUNT(*)\",\n \"check_types([(\\\"n\\\", n, [int, float])]) return self.apply(func=\\\"ROUND({}, {})\\\".format(\\\"{}\\\", n)) # ---#\",\n \"func, [str]), (\\\"copy_name\\\", copy_name, [str])]) try: try: ctype = get_data_types(\",\n \"h, ax=ax, **style_kwds) # ---# def iloc(self, limit: int =\",\n \"if pie_type == \\\"rose\\\" else False if of: self.parent.are_namecols_in(of) of\",\n \"tan : trigonometric tangent tanh : hyperbolic tangent x: int/float,\",\n \"{} LIMIT 1\\\".format( self.alias, cast, self.parent.__genSQL__(), self.parent.__get_last_order_by__(), index, ) return\",\n \"field: str): \\\"\\\"\\\" --------------------------------------------------------------------------- Extracts a specific TS field from\",\n \"int = 0, h: float = 0, ax=None, **style_kwds, ):\",\n \"int])]) assert (lower != None) or (upper != None), ParameterError(\",\n \"frequent elements will be gathered together to create a new\",\n \"method. new_category: str, optional The name of the merging category\",\n \"vDataFrame[].dropna : Drops the vColumn missing values. \\\"\\\"\\\" if isinstance(by,\",\n \"name = ( '\\\"{}{}\\\"'.format(prefix, k) if (use_numbers_as_suffix) else '\\\"{}{}\\\"'.format( prefix,\",\n \"setattr(self.parent, name, new_vColumn) setattr(self.parent, name.replace('\\\"', \\\"\\\"), new_vColumn) self.parent._VERTICAPY_VARIABLES_[\\\"columns\\\"] += [name]\",\n \"= ( \\\"WHEN {} > {} THEN {} \\\".format(\\\"{}\\\", upper,\",\n \"\\\"NULLIFZERO\\\" if (nullifzero) else \\\"\\\", stddev ) else: final_transformation =\",\n \"\\\"nbins\\\": 100}) model.set_params(RFmodel_params) parameters = model.get_params() try: model.fit(tmp_view_name, [self.alias], response)\",\n \"\\\"\\\"\\\" if isinstance(method, str): method = method.lower() check_types( [ (\\\"method\\\",\",\n \"\\\"WHERE _verticapy_row_nb_ IN ({})\\\".format( \\\", \\\".join([\\\"1\\\"] + nth_elems + [str(count)])\",\n \"AS 'index', COUNT({1}) AS count, 100 * COUNT({1}) / {2}\",\n \"= self.parent.shape()[0] self.catalog[\\\"percent\\\"] = 100 self.parent.__add_to_history__( \\\"[Label Encoding]: Label Encoding\",\n \"during the computation. Returns ------- tablesample An object containing the\",\n \"Value to use to impute the vColumn. method: dict, optional\",\n \"\\\"\\\"\\\" --------------------------------------------------------------------------- Looks if some specific records are in the\",\n \"else: xmin, xmax = xlim custom_lines = [] columns =\",\n \"\\\"\\\"\\\" --------------------------------------------------------------------------- Fills missing elements in the vColumn with a\",\n \"> {} THEN {} ELSE {} END)\\\".format( \\\"{}\\\", p_alpha, mean_alpha,\",\n \": trigonometric cosine cosh : hyperbolic cosine cot : trigonometric\",\n \"of another number round : rounds a value to a\",\n \"Warning) return self elif (n == 1) and (self.parent[by[0]].nunique() <\",\n \"_| _ /~\\\\ _ |. # |_)\\\\/ |_)(_|(_|| \\\\_/|_|(_||| #\",\n \"return to_tablesample(query, title=title) # ---# def numh(self, method: str =\",\n \"LIMIT 1\\\".format( alpha, self.alias, alpha, self.alias, self.parent.__genSQL__() ) p_alpha, p_1_alpha\",\n \"method == \\\"minmax\\\": self.catalog[elem] = (sauv[elem] - sauv[\\\"min\\\"]) / (\",\n \"model.set_params({\\\"n_estimators\\\": 20, \\\"max_depth\\\": 8, \\\"nbins\\\": 100}) model.set_params(RFmodel_params) parameters = model.get_params()\",\n \"ELSE '{}' END)\\\".format( bin_spatial_to_str(self.category()), \\\", \\\".join( [ \\\"'{}'\\\".format(str(elem).replace(\\\"'\\\", \\\"''\\\")) for\",\n \"def clip(self, lower=None, upper=None): \\\"\\\"\\\" --------------------------------------------------------------------------- Clips the vColumn by\",\n \"def apply_fun(self, func: str, x: float = 2): \\\"\\\"\\\" ---------------------------------------------------------------------------\",\n \"return self.transformations[-1][1].lower() dtype = ctype # ---# def date_part(self, field:\",\n \"({} ORDER BY {}))\\\".format( \\\"{}\\\", \\\"{}\\\", partition_by, order_by_ts ) if\",\n \"Extracts the regular expression in each record of the vColumn.\",\n \"an input value. vDataFrame[].str_slice : Slices the vColumn. \\\"\\\"\\\" check_types([(\\\"pat\\\",\",\n \"in (\\\"bool\\\", \\\"boolean\\\") # ---# def isdate(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns\",\n \"self.ctype() tail.name = self.alias return tail # ---# def isbool(self):\",\n \"self.parent.are_namecols_in(by) by = self.parent.format_colnames(by) from verticapy.plot import gen_colors from matplotlib.lines\",\n \"the following: (function, type, category) parent: vDataFrame, optional Parent of\",\n \"else: if not (\\\"color\\\" in kwargs): from verticapy.plot import gen_colors\",\n \"optional vColumn to use to partition the TS. start_date: str\",\n \"'std' (Standard Deviation). Returns ------- float std See Also --------\",\n \"vDataFrame.fill_outliers : Fills the outliers in the vColumn. vDataFrame.outliers :\",\n \"quantiles of {}.\\\".format(self.alias), method=\\\"fetchrow\\\", ) if method == \\\"winsorize\\\": self.clip(lower=p_alpha,\",\n \"tail of the vColumn. \\\"\\\"\\\" check_types([(\\\"limit\\\", limit, [int, float]), (\\\"offset\\\",\",\n \"--------------------------------------------------------------------------- Adds a copy vColumn to the parent vDataFrame. Parameters\",\n \"to use to impute the vColumn. method: dict, optional Method\",\n \"= to_tablesample( \\\"SELECT {} AS {} FROM {}{} LIMIT {}\",\n \"decimal places sign : arithmetic sign sin : trigonometric sine\",\n \"True, alpha: float = 0.05 ): \\\"\\\"\\\" --------------------------------------------------------------------------- Drops outliers\",\n \"method == \\\"mean\\\": query = \\\"WITH vdf_table AS (SELECT *\",\n \"elif method == \\\"null\\\": self.apply( func=\\\"(CASE WHEN ({} BETWEEN {}\",\n \"verticapy.options[\\\"print_info\\\"]: print(\\\"The mean encoding was successfully done.\\\") return self.parent #\",\n \") if of: self.parent.are_namecols_in(of) of = self.parent.format_colnames(of) from verticapy.plot import\",\n \"input method. Parameters ---------- method: str, optional The describe method.\",\n \"mad See Also -------- vDataFrame.aggregate : Computes the vDataFrame input\",\n \"int, float], ), (\\\"plot_median\\\", plot_median, [bool]), ] ) self.parent.are_namecols_in(ts) ts\",\n \") if verticapy.options[\\\"print_info\\\"]: print(\\\"The mean encoding was successfully done.\\\") return\",\n \"from verticapy.plot import spider as spider_plot return spider_plot( self.parent, columns,\",\n \"vDataFrame.expected_store_usage : Returns the vDataFrame expected store usage. \\\"\\\"\\\" pre_comp\",\n \"work if it is part of the DB version you\",\n \"function. For more information, see: https://geopandas.readthedocs.io/en/latest/docs/reference/api/ geopandas.GeoDataFrame.plot.html Returns ------- ax\",\n \"------- vDataFrame self.parent See Also -------- vDataFrame[].apply : Applies a\",\n \"optional The interval size to convert to use to convert\",\n \"\\\"numerical\\\")) or not (is_numeric) or (method == \\\"categorical\\\") ): query\",\n \"processing, VerticaPy brings the logic to the data. # #\",\n \"float])]) query = \\\"SELECT * FROM {} WHERE {} IS\",\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\",\n \"False, the function's performance can drastically decrease. Returns ------- float/str\",\n \"self.isnum(): if method == \\\"zscore\\\": if n == 0: nullifzero\",\n \"Apache License, Version 2.0 (the \\\"License\\\"); # You may not\",\n \"\\\"SELECT {}, {}({}) FROM {} GROUP BY {};\\\".format( by[0], fun,\",\n \"\\\" FROM vdf_table WHERE {0} IS NOT NULL GROUP BY\",\n \"the result. For more information, see utilities.tablesample. See Also --------\",\n \"absolute deviation approx_unique : approximative cardinality count : number of\",\n \"\\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using 'mad' (median absolute deviation).\",\n \"tangent tanh : hyperbolic tangent x: int/float, optional If the\",\n \"(k < 1) else \\\"LIMIT {}\\\".format(k) dropna = \\\" WHERE\",\n \"\\\"\\\"\\\" --------------------------------------------------------------------------- Draws the spider plot of the input vColumn\",\n \") donut = True if pie_type == \\\"donut\\\" else False\",\n \"computed) nbins: int, optional Number of nbins. If empty, an\",\n \"x: int/float, optional If the function has two arguments (example,\",\n \"= (14, 10) return self.parent[columns].to_geopandas(self.alias).plot(*args, **kwargs) # ---# def get_dummies(\",\n \"case, the parameter 'numcol' must be defined. numerical : Uses\",\n \"the next element (Constant Interpolation). ffill : Propagation of the\",\n \"= [] prefix = ( self.alias.replace('\\\"', \\\"\\\") + prefix_sep.replace('\\\"', \\\"_\\\")\",\n \"vDataFrame by using an advanced analytical function on a specific\",\n \"information, see utilities.tablesample. See Also -------- vDataFrame[].head : Returns the\",\n \"\\\"numerical\\\", \\\"categorical\\\", \\\"cat_stats\\\"]), (\\\"max_cardinality\\\", max_cardinality, [int, float]), (\\\"numcol\\\", numcol, [str]),\",\n \"optional If set to True, the approximate quantile is returned.\",\n \"return self.apply(func=\\\"ABS({})\\\") # ---# def add(self, x: float): \\\"\\\"\\\" ---------------------------------------------------------------------------\",\n \"self.parent one_hot_encode = get_dummies # ---# def head(self, limit: int\",\n \"NOT NULL ORDER BY {} ASC LIMIT {}\\\".format( self.parent.__genSQL__(), self.alias,\",\n \"IN ({})\\\".format( \\\", \\\".join([\\\"1\\\"] + nth_elems + [str(count)]) ) query\",\n \"'{0}' AS 'index', COUNT({1}) AS count, 100 * COUNT({1}) /\",\n \"= index.stop index_start = index.start if not (isinstance(index_start, int)): index_start\",\n \"result if elem[1] != None ] ), ) stddev =\",\n \"vColumn 'of' (ex: 50% to get the median). It can\",\n \"nbins using Random Forest.\\\", method=\\\"fetchall\\\", ) result = [elem[0] for\",\n \"auto : Mean for the numerical and Mode for the\",\n \"Also -------- vDataFrame[].isbool : Returns True if the vColumn is\",\n \"self, ts, by, start_date, end_date, area, step, ax=ax, **style_kwds, )\",\n \"method=\\\"fetchall\\\", ) ] if mean_alpha == None: mean_alpha = \\\"NULL\\\"\",\n \"\\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using multiple statistical aggregations: min,\",\n \"drawing the box plot. The other categories will be filtered.\",\n \"/ ({})\\\".format(\\\"{}\\\", med, mad), \\\"float\\\", \\\"float\\\", ) ] else: warning_message\",\n \"/ / # \\\\/ / / # / / #\",\n \"threshold to use to determine if the vColumn will be\",\n \"check: self.parent.are_namecols_in(column) column = self.parent.format_colnames(column) columns += [column] if not\",\n \"vDataFrame input aggregations. \\\"\\\"\\\" return self.aggregate([\\\"mad\\\"]).values[self.alias][0] # ---# def max(self):\",\n \"Robust Z-Score (median and mad). (x - median) / (1.4826\",\n \"vColumn. Parameters ---------- func: str Function to use to transform\",\n \"\\\"(CASE {}{}ELSE {} END)\\\".format(lower_when, upper_when, \\\"{}\\\") self.apply(func=func) return self.parent #\",\n \"start: bool = True): \\\"\\\"\\\" --------------------------------------------------------------------------- Slices and transforms the\",\n \"self.isnum() or self.isdate(), ParameterError( \\\"numh is only available on type\",\n \"# ---# def skewness(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using\",\n \"self.apply( func=\\\"(CASE WHEN {} < {} THEN {} WHEN {}\",\n \"---# def isin(self, val: list, *args): \\\"\\\"\\\" --------------------------------------------------------------------------- Looks if\",\n \"distinct = self.topk(k).values[\\\"index\\\"] trans = ( \\\"(CASE WHEN {} IN\",\n \"\\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using an input 'quantile'. Parameters\",\n \"the vColumn is numerical. \\\"\\\"\\\" return self.category() == \\\"date\\\" #\",\n \"law or agreed to in writing, software # distributed under\",\n \"or ( self.isnum() and method == \\\"smart\\\" ): n =\",\n \"some specific records are in the vColumn and it returns\",\n \"BY {})\\\".format( self.alias, \\\", \\\".join(by) ), ) else: cmax, cmin\",\n \"fun = \\\"MEDIAN\\\" if (method == \\\"median\\\") else \\\"AVG\\\" if\",\n \"donut = True if pie_type == \\\"donut\\\" else False rose\",\n \"(\\\"{}\\\", self.ctype(), self.category()) ] self.parent[copy_name].transformations += [(func, ctype, category)] self.parent[copy_name].catalog\",\n \"\\\"[Label Encoding]: Label Encoding was applied to the vColumn {}\",\n \"query = \\\"SELECT COUNT({}) AS NAs, MIN({}) AS min, APPROXIMATE_PERCENTILE({}\",\n \"(pt_non_events - pt_events) * ZEROIFNULL(LN(pt_non_events / NULLIFZERO(pt_events))) END AS iv\",\n \"stored in the vDataFrame history. Returns ------- vDataFrame self.parent See\",\n \"- 1): first_elem, second_elem = breaks[idx], breaks[idx + 1] if\",\n \"\\\"SELECT {} AS {} FROM {} WHERE {} IS NOT\",\n \"the transformation instead of the vDataFrame parent and do not\",\n \"\\\"minmax\\\": self.catalog[\\\"min\\\"] = 0 self.catalog[\\\"max\\\"] = 1 self.parent.__add_to_history__( \\\"[Normalize]: The\",\n \"with the method '{}'.\\\".format( self.alias, method ) ) else: raise\",\n \"self.alias, self.parent.shape()[0], self.parent.__genSQL__(), dropna, self.alias, topk, ) result = executeSQL(\",\n \"nbins: int, optional Maximum number of points to use to\",\n \"\\\" UNION ALL \\\".join(query) ) title = \\\"Describes the statics\",\n \"this issue.\\\" ) new_vColumn = vColumn( name, parent=self.parent, transformations=[item for\",\n \"were \\\" if len(all_new_features) > 1 else \\\" was \\\"\",\n \"\\\\ /\\\\ \\\"-.\\\\ \\\\ # \\\\ \\\\ \\\\'/ \\\\ \\\\\",\n \"= self.parent.shape()[0] tail.offset = offset tail.dtype[self.alias] = self.ctype() tail.name =\",\n \"{}, MIN(ord) AS ord, SUM(1 - {}) AS non_events, SUM({})\",\n \"(1, None), ValueError( \\\"vColumn doesn't allow slicing having steps different\",\n \"= [ ( \\\"({} - {}) / {}({})\\\".format( \\\"{}\\\", avg,\",\n \"assert len(breaks) == len(labels) + 1 or not (labels), ParameterError(\",\n \"\\\"numh\\\") if pre_comp != \\\"VERTICAPY_NOT_PRECOMPUTED\\\": return pre_comp assert self.isnum() or\",\n \"str, optional vColumn to use to partition the TS. start_date:\",\n \"return. Returns ------- tablesample An object containing the result. For\",\n \"self.parent.__genSQL__() ), print_time_sql=False, ) except: avg, stddev = ( \\\"AVG({})\",\n \"False, n: int = 1): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns the nth\",\n \"sequentialize # data transformation operations, and offers beautiful graphical options.\",\n \"\\\", \\\".join(expr) + \\\", {})\\\".format(len(distinct_elements)) self.transformations += [(expr, \\\"int\\\", \\\"int\\\")]\",\n \"n = 1 if drop_first else 0 for k in\",\n \"print(\\\"Nothing was filled.\\\") self.transformations = [elem for elem in copy_trans]\",\n \"from verticapy.learn.neighbors import KernelDensity schema = verticapy.options[\\\"temp_schema\\\"] if not (schema):\",\n \"method = method.lower() check_types( [ (\\\"method\\\", method, [\\\"winsorize\\\", \\\"null\\\", \\\"mean\\\"]),\",\n \"of the dummies. drop_first: bool, optional Drops the first dummy\",\n \"Method to use to fill the vColumn outliers. mean :\",\n \"1\\\".format( avg, stddev, self.parent.__genSQL__() ), print_time_sql=False, ) except: avg, stddev\",\n \"vColumn_025, vColumn_075, vColumn_max = result sturges = max( float(vColumn_max -\",\n \"\\\"\\\", stddev ), \\\"float\\\", \\\"float\\\", ) ] elif method ==\",\n \"variable. Parameters ---------- y: str Response vColumn. nbins: int, optional\",\n \"generation will be slower if the vDataFrame has been transformed\",\n \"the current vColumn and creating a copy with the specified\",\n \"use_threshold: result = self.aggregate(func=[\\\"std\\\", \\\"avg\\\"]).transpose().values self.parent.filter( \\\"ABS({} - {}) /\",\n \"vDataFrame[].str_slice : Slices the vColumn. \\\"\\\"\\\" check_types([(\\\"pat\\\", pat, [str])]) return\",\n \"for category in cat: tmp_query = \\\"\\\"\\\"SELECT '{0}' AS 'index',\",\n \"= float(top) self.parent.__update_catalog__( {\\\"index\\\": [\\\"top{}\\\".format(n)], self.alias: [top]} ) return top\",\n \"fill the vColumn outliers. mean : Replaces the upper and\",\n \"mad). (x - median) / (1.4826 * mad) minmax :\",\n \"invalid. max_cardinality: int/tuple, optional Maximum number of distinct elements for\",\n \"== 1: pre_comp = self.parent.__get_catalog_value__(self.alias, \\\"top\\\") if pre_comp != \\\"VERTICAPY_NOT_PRECOMPUTED\\\":\",\n \"sauv[\\\"approx_50%\\\"]) / ( 1.4826 * sauv[\\\"mad\\\"] ) elif method ==\",\n \": Draws the histogram of the vColumn based on an\",\n \"warning_message = \\\"Can not normalize {} using a Z-Score -\",\n \"def date_part(self, field: str): \\\"\\\"\\\" --------------------------------------------------------------------------- Extracts a specific TS\",\n \"[elem[0] for elem in result] elif self.isnum() and method in\",\n \": natural logarithm log : logarithm log10 : base 10\",\n \"range(len(distinct_elements) - n): name = ( '\\\"{}{}\\\"'.format(prefix, k) if (use_numbers_as_suffix)\",\n \"- n): name = ( '\\\"{}{}\\\"'.format(prefix, k) if (use_numbers_as_suffix) else\",\n \"index_start if limit <= 0: limit = 0 limit =\",\n \"in transformations], ) self.catalog = { \\\"cov\\\": {}, \\\"pearson\\\": {},\",\n \"to True, NULL values will not be considered during the\",\n \"vDataFrame Global Outliers. \\\"\\\"\\\" if isinstance(by, str): by = [by]\",\n \"str): \\\"\\\"\\\" --------------------------------------------------------------------------- Encodes the vColumn using the average of\",\n \"log : logarithm log10 : base 10 logarithm mod :\",\n \"of the next element (Constant Interpolation). ffill : Propagation of\",\n \"AS max FROM vdf_table\\\"\\\"\\\".format( category, self.alias, self.parent.shape()[0], numcol, cast, )\",\n \"1.4826 if mad != 0: if return_trans: return \\\"({} -\",\n \"(median and mad). (x - median) / (1.4826 * mad)\",\n \"function to all the vColumns. vDataFrame.eval : Evaluates a customized\",\n \"= \\\"NULL\\\" self.apply( func=\\\"(CASE WHEN {} < {} THEN {}\",\n \"\\\"varchar\\\", \\\"text\\\") if return_enum_trans: return trans else: self.transformations += [trans]\",\n \"\\\"log10\\\", \\\"mod\\\", \\\"pow\\\", \\\"round\\\", \\\"sign\\\", \\\"sin\\\", \\\"sinh\\\", \\\"sqrt\\\", \\\"tan\\\", \\\"tanh\\\",\",\n \"True if pie_type == \\\"rose\\\" else False if of: self.parent.are_namecols_in(of)\",\n \"input element. Parameters ---------- x: float Input number. Returns -------\",\n \"optional Input Start Date. For example, time = '03-11-1993' will\",\n \"Computes the vDataFrame input aggregations. \\\"\\\"\\\" return self.quantile(0.5, approx=approx) #\",\n \"in sauv: self.catalog[\\\"count\\\"] = sauv[\\\"count\\\"] self.catalog[\\\"percent\\\"] = ( 100 *\",\n \"(Average). Returns ------- float average See Also -------- vDataFrame.aggregate :\",\n \"value. \\\"\\\"\\\" check_types([(\\\"start\\\", start, [int, float]), (\\\"step\\\", step, [int, float])])\",\n \"= self.avg() elif fun == \\\"MEDIAN\\\": val = self.median() new_column\",\n \"/ # \\\\_______/ / / # ______ / / #\",\n \"type is date like). The vColumn will be transformed. Parameters\",\n \"\\\"count\\\", \\\"mean\\\", \\\"std\\\", \\\"min\\\", \\\"approx_25%\\\", \\\"approx_50%\\\", \\\"approx_75%\\\", \\\"max\\\", ] if\",\n \"\\\"avg\\\"]).transpose().values self.parent.filter( \\\"ABS({} - {}) / {} < {}\\\".format( self.alias,\",\n \"AS std, MIN({3}{4}) AS min, APPROXIMATE_PERCENTILE ({3}{4} USING PARAMETERS percentile\",\n \"{} LIMIT 1\\\".format( avg, stddev, self.parent.__genSQL__() ), print_time_sql=False, ) except:\",\n \"drop(tmp_model_name, method=\\\"model\\\") result = [self.min()] + result + [self.max()] elif\",\n \"else: query = \\\"SELECT PERCENTILE_CONT({}) WITHIN GROUP (ORDER BY {})\",\n \"else '\\\"{}{}\\\"'.format( prefix, str(distinct_elements[k]).replace('\\\"', \\\"_\\\") ) ) name = (\",\n \"self, ts: str, by: str = \\\"\\\", start_date: Union[str, datetime.datetime,\",\n \"be computed. h: float, optional Interval width of the bar.\",\n \"\\\"\\\"), new_vColumn) self.parent._VERTICAPY_VARIABLES_[\\\"columns\\\"] += [name] all_new_features += [name] conj =\",\n \"# ---# def nlargest(self, n: int = 10): \\\"\\\"\\\" ---------------------------------------------------------------------------\",\n \"booleans\\\".format(self.alias) warnings.warn(warning_message, Warning) elif self.isnum(): if method == \\\"zscore\\\": if\",\n \"MIN !\\\".format( self.alias ) warnings.warn(warning_message, Warning) return self elif n\",\n \"Q3, MAX({}) AS max FROM {}\\\".format( self.alias, self.alias, self.alias, self.alias,\",\n \"Aggregates the vColumn using 'count' (Number of non-Missing elements). Returns\",\n \"as e: self.transformations = [elem for elem in copy_trans] raise\",\n \"using 'product'. Returns ------- float product See Also -------- vDataFrame.aggregate\",\n \"{}, COUNT(*) AS _verticapy_cnt_ FROM {}{}GROUP BY {} ORDER BY\",\n \"check_types( [ (\\\"length\\\", length, [int, float]), (\\\"unit\\\", unit, [str]), (\\\"start\\\",\",\n \"1 or not (labels), ParameterError( \\\"Length of parameter breaks must\",\n \"a Z-Score - The Standard Deviation is null !\\\".format( self.alias\",\n \"\\\"\\\"\\\" --------------------------------------------------------------------------- Returns the tail of the vColumn. Parameters ----------\",\n \"set to True, draw a Step Plot. ax: Matplotlib axes\",\n \"to the vDataFrame by using an advanced analytical function on\",\n \"vColumn. \\\"\\\"\\\" check_types([(\\\"pat\\\", pat, [str])]) return self.apply( func=\\\"REGEXP_SUBSTR({}, '{}')\\\".format(\\\"{}\\\", pat.replace(\\\"'\\\",\",\n \"set to True, the information will be stored in the\",\n \"# # ---# def aad(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn\",\n \"(\\\"bool\\\", \\\"boolean\\\") # ---# def isdate(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns True\",\n \"the vDataFrame.\\\".format( self.alias, name ) ) return self.parent # ---#\",\n \"dropna, self.alias, topk, ) result = executeSQL( query, title=\\\"Computing the\",\n \"method.lower() if self.isnum() and method == \\\"smart\\\": schema = verticapy.options[\\\"temp_schema\\\"]\",\n \"vColumn. vDataFrame[].get_dummies : Encodes the vColumn with One-Hot Encoding. vDataFrame[].mean_encode\",\n \"float]), (\\\"h\\\", h, [int, float]), ] ) if of: self.parent.are_namecols_in(of)\",\n \"**style_kwds, ) # ---# def rename(self, new_name: str): \\\"\\\"\\\" ---------------------------------------------------------------------------\",\n \"to the vColumn. Parameters ---------- x: float If the vColumn\",\n \"= self.aggregate([\\\"avg\\\", \\\"std\\\"]).values[self.alias] if stddev == 0: warning_message = \\\"Can\",\n \"discretize( self, method: str = \\\"auto\\\", h: float = 0,\",\n \"\\\"robust_zscore\\\": self.catalog[\\\"median\\\"] = 0 self.catalog[\\\"mad\\\"] = 1 / 1.4826 elif\",\n \"str = \\\"auto\\\", h: float = 0, nbins: int =\",\n \"q, start_date, end_date, plot_median, ax=ax, **style_kwds, ) # ---# def\",\n \"or implied. # See the License for the specific language\",\n \"on. **style_kwds Any optional parameter to pass to the Matplotlib\",\n \"\\\"kendall\\\": {}, \\\"cramer\\\": {}, \\\"biserial\\\": {}, \\\"regr_avgx\\\": {}, \\\"regr_avgy\\\": {},\",\n \"(must be > 1) k: int, optional The integer k\",\n \"logistic : Logistic kernel. sigmoid : Sigmoid kernel. silverman :\",\n \"the vColumn by keeping only the input number of digits\",\n \"histogram nbins using Random Forest.\\\", method=\\\"fetchall\\\", ) result = [elem[0]\",\n \"= executeSQL( \\\"SELECT {} FROM (SELECT {}, COUNT(*) AS _verticapy_cnt_\",\n \"gen_cmap kwargs[\\\"cmap\\\"] = gen_cmap()[0] else: if not (\\\"color\\\" in kwargs):\",\n \"# # Methods # # ---# def aad(self): \\\"\\\"\\\" ---------------------------------------------------------------------------\",\n \"aggregation. vColumns will memorize the already computed aggregations to gain\",\n \"'k' must be greater or equals to 2 in case\",\n \"or self.isbool(): all_new_features = [] prefix = ( self.alias.replace('\\\"', \\\"\\\")\",\n \"self.alias, \\\", \\\".join(by) ), ) else: avg, stddev = (\",\n \"def distinct(self, **kwargs): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns the distinct categories of\",\n \"--------------------------------------------------------------------------- Subtracts the input element from the vColumn. Parameters ----------\",\n \") return self.parent # ---# def dropna(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Filters\",\n \"usage. \\\"\\\"\\\" import sys total = ( sys.getsizeof(self) + sys.getsizeof(self.alias)\",\n \">= 2, ParameterError( \\\"Parameter 'nbins' must be greater or equals\",\n \"method, [str]), (\\\"of\\\", of, [str]), (\\\"max_cardinality\\\", max_cardinality, [list]), (\\\"h\\\", h,\",\n \"/ 1.4826 elif method == \\\"zscore\\\": self.catalog[\\\"mean\\\"] = 0 self.catalog[\\\"std\\\"]\",\n \"Adds the input element to the vColumn. Parameters ---------- x:\",\n \"be a cutomized aggregation (ex: AVG(column1) + 5). of: str,\",\n \"-------- vDataFrame.iv_woe : Computes the Information Value (IV) Table. \\\"\\\"\\\"\",\n \"and a limit). Parameters ---------- limit: int, optional Number of\",\n \"the vColumns to the input type. \\\"\\\"\\\" check_types([(\\\"dtype\\\", dtype, [str])])\",\n \"---------- *args / **kwargs Any optional parameter to pass to\",\n \"function to the vColumn. Parameters ---------- func: str, Function in\",\n \"record is greater than the threshold, it will be considered\",\n \"vColumn {} has no mode (only missing values).\\\\nNothing was filled.\\\".format(\",\n \"method.lower() check_types( [ (\\\"method\\\", method, [\\\"winsorize\\\", \\\"null\\\", \\\"mean\\\"]), (\\\"alpha\\\", alpha,\",\n \"science life cycle, uses a ‘pipeline’ mechanism to sequentialize #\",\n \"be composed of two flower brackets {}. For example to\",\n \"root tan : trigonometric tangent tanh : hyperbolic tangent x:\",\n \"Computes regular width bins. smart : Uses the Random Forest\",\n \"information will be stored in the vDataFrame history. Returns -------\",\n \"warnings, datetime from collections.abc import Iterable from typing import Union\",\n \"self.category() == \\\"int\\\": h = int(max(math.floor(h), 1)) floor_end = -1\",\n \"= self.transformations + [(expr, \\\"bool\\\", \\\"int\\\")] new_vColumn = vColumn( name,\",\n \"= [distinct_count] + result index = [ \\\"unique\\\", \\\"count\\\", \\\"mean\\\",\",\n \"= self.numh() else: h = (self.max() - self.min()) * 1.01\",\n \"use iv_woe.\\\".format(y) ) self.parent[y].distinct() trans = self.discretize( method=\\\"same_width\\\" if self.isnum()\",\n \"= [ ( \\\"({} - {}) / ({})\\\".format(\\\"{}\\\", med, mad),\",\n \"- {}) / ({})\\\".format(\\\"{}\\\", med, mad), \\\"float\\\", \\\"float\\\", ) ]\",\n \"\\\"'{}'\\\".format(str(elem).replace(\\\"'\\\", \\\"''\\\")) for elem in distinct ] ), bin_spatial_to_str(self.category()), new_category.replace(\\\"'\\\",\",\n \"most occurent elements to return. dropna: bool, optional If set\",\n \"result = to_tablesample(query, title=title) result.values[\\\"index\\\"] += [\\\"total\\\"] result.values[\\\"non_events\\\"] += [sum(result[\\\"non_events\\\"])]\",\n \"\\\"\\\"\\\" if \\\"agg\\\" not in kwargs: query = \\\"SELECT {}\",\n \"numerical, False otherwise. Returns ------- bool True if the vColumn\",\n \"optional Interval width of the vColumns 1 and 2 bars.\",\n \") ) # ---# def str_slice(self, start: int, step: int):\",\n \"'approx_75%', APPROXIMATE_PERCENTILE ({3}{4} USING PARAMETERS percentile = 0.9) AS 'approx_90%',\",\n \"APPROXIMATE_PERCENTILE ({3}{4} USING PARAMETERS percentile = 0.25) AS 'approx_25%', APPROXIMATE_PERCENTILE\",\n \"if len(cat) == 1: lp, rp = \\\"(\\\", \\\")\\\" else:\",\n \"aggregations used are the median and two input quantiles. Parameters\",\n \"input aggregations. \\\"\\\"\\\" check_types( [ (\\\"method\\\", method, [\\\"auto\\\", \\\"numerical\\\", \\\"categorical\\\",\",\n \"self.transformations += final_transformation sauv = {} for elem in self.catalog:\",\n \"in each of the vColumn records. The vColumn will be\",\n \"other categories will be filtered. ax: Matplotlib axes object, optional\",\n \"# ---# def slice(self, length: int, unit: str = \\\"second\\\",\",\n \"and 2 bars. It is only valid if the vColumns\",\n \"n): trans += \\\"WHEN {} BETWEEN {} AND {} THEN\",\n \"that relation. vColumns simplify several processes with its abstractions. Parameters\",\n \"Iterable)): cat_priority = [cat_priority] check_types( [ (\\\"by\\\", by, [str]), (\\\"max_cardinality\\\",\",\n \"= max(0, self.parent.shape()[0] - limit) title = \\\"Reads {}.\\\".format(self.alias) tail\",\n \"method: str, optional The method to use to discretize the\",\n \"median. mode : mode (most occurent element). 0ifnull : 0\",\n \"ParameterError( \\\"Parameter 'k' must be greater or equals to 2\",\n \"average median : median min : minimum mode : most\",\n \"self, val=None, method: str = \\\"auto\\\", expr: str = \\\"\\\",\",\n \"return self.count() > 0 # ---# def __repr__(self): return self.head(limit=verticapy.options[\\\"max_rows\\\"]).__repr__()\",\n \"[(func, ctype, category)] self.parent.__update_catalog__(erase=True, columns=[self.alias]) self.parent.__add_to_history__( \\\"[Apply]: The vColumn '{}'\",\n \"drastically decrease. Returns ------- float quantile (or approximate quantile). See\",\n \"query = \\\"SELECT PERCENTILE_CONT({}) WITHIN GROUP (ORDER BY {}) OVER\",\n \"= (trans, \\\"varchar\\\", \\\"text\\\") if return_enum_trans: return trans else: self.transformations\",\n \"-> {}'.\\\".format( copy_name.replace('\\\"', \\\"\\\"), func.replace(\\\"{}\\\", \\\"x\\\"), ) ) else: for\",\n \"all of the above. The idea is simple: instead of\",\n \"extract. It must be one of the following: CENTURY /\",\n \"None)) else \\\" WHERE {} = '{}'\\\".format( bin_spatial_to_str(self.category(), self.alias), category,\",\n \"(method == \\\"categorical\\\")) or ( method == \\\"is_numeric\\\" ): self.parent.__update_catalog__({\\\"index\\\":\",\n \"\\\"text\\\", ) else: trans = (\\\"FLOOR({}) || ''\\\", \\\"varchar\\\", \\\"text\\\")\",\n \"else: for k in range(max_floor): self.transformations += [(\\\"{}\\\", self.ctype(), self.category())]\",\n \"\\\"\\\"\\\" --------------------------------------------------------------------------- Applies the absolute value function to the input\",\n \"the plot. gaussian : Gaussian kernel. logistic : Logistic kernel.\",\n \"\\\"\\\"), EmptyParameter( \\\"The parameter 'name' must not be empty\\\" )\",\n \"final generated SQL code. Note: Dropping a vColumn can make\",\n \"= \\\" LIMIT {}\\\".format(limit) else: limit = \\\"\\\" query =\",\n \"\\\\_\\\\ \\\\ \\\\_\\\\\\\\\\\"\\\\_\\\\ # \\\\/_/ \\\\/_____/ \\\\/_____/ \\\\/_____/ \\\\/_____/ \\\\/_/\",\n \"( self.isnum() and method == \\\"smart\\\" ): n = len(result)\",\n \"= ( \\\"PARTITION BY {}\\\".format( \\\", \\\".join([quote_ident(column) for column in\",\n \"conditions += [ f\\\"'{first_elem}' {op1} {column} AND {column} {op2} '{second_elem}'\",\n \"self.parent.format_colnames(by) from verticapy.plot import ts_plot return ts_plot( self, ts, by,\",\n \"be considered as categorical. numcol: str, optional Numerical vColumn to\",\n \"self.catalog[\\\"count\\\"] = sauv[\\\"count\\\"] self.catalog[\\\"percent\\\"] = ( 100 * sauv[\\\"count\\\"] /\",\n \"val = [val] val += list(args) check_types([(\\\"val\\\", val, [list])]) val\",\n \"it will be considered as an outlier. use_threshold: bool, optional\",\n \"if elem[1] != None ] ), ) stddev = \\\"DECODE({},\",\n \"q Quantile of the vColumn 'of' (ex: 50% to get\",\n \"import * ## # # __ __ ______ ______ __\",\n \": Computes the vDataFrame input aggregations. \\\"\\\"\\\" return self.aggregate([\\\"max\\\"]).values[self.alias][0] #\",\n \"(self.isnum() and method == \\\"same_freq\\\") or ( self.isnum() and method\",\n \"= 0 cmin, cmax = self.aggregate([\\\"min\\\", \\\"max\\\"]).values[self.alias] if cmax -\",\n \"another number round : rounds a value to a specified\",\n \"import gen_colors kwargs[\\\"color\\\"] = gen_colors()[0] if not (\\\"legend\\\" in kwargs):\",\n \") count, vColumn_min, vColumn_025, vColumn_075, vColumn_max = result sturges =\",\n \"+= [(func, ctype, category)] self.parent[copy_name].catalog = self.catalog self.parent.__add_to_history__( \\\"[Apply]: The\",\n \"vColumn based on an aggregation. \\\"\\\"\\\" check_types( [ (\\\"by\\\", by,\",\n \"method: str = \\\"auto\\\", max_cardinality: int = 6, numcol: str\",\n \"happened during the filling.\\\".format(e)) if total > 0: try: if\",\n \"bin_spatial_to_str(self.category(), self.alias), self.parent.__genSQL__(), ), title=\\\"Computing the Store Usage of the\",\n \"max_cardinality, [list]), (\\\"h\\\", h, [list, float, int]), ] ) if\",\n \"= ctype # ---# def date_part(self, field: str): \\\"\\\"\\\" ---------------------------------------------------------------------------\",\n \"function to the input vColumn. \\\"\\\"\\\" check_types( [ (\\\"breaks\\\", breaks,\",\n \"\\\"zscore\\\", by: list = [], return_trans: bool = False ):\",\n \"{} {} smallest elements.\\\".format(n, self.alias) return to_tablesample(query, title=title) # ---#\",\n \"with One-Hot Encoding. vDataFrame[].mean_encode : Encodes the vColumn using the\",\n \"filtered. ax: Matplotlib axes object, optional The axes to plot\",\n \"List of the different transformations. Each transformation must be similar\",\n \"check_types([(\\\"to_replace\\\", to_replace, [str]), (\\\"value\\\", value, [str])]) return self.apply( func=\\\"REGEXP_REPLACE({}, '{}',\",\n \"\\\"func\\\", func, [ \\\"abs\\\", \\\"acos\\\", \\\"asin\\\", \\\"atan\\\", \\\"cbrt\\\", \\\"ceil\\\", \\\"cos\\\",\",\n \": Computes regular width bins. smart : Uses the Random\",\n \"approx: bool, optional If set to True, the approximate quantile\",\n \"1 / 1.4826 elif method == \\\"zscore\\\": self.catalog[\\\"mean\\\"] = 0\",\n \"new_category: str = \\\"Others\\\", RFmodel_params: dict = {}, response: str\",\n \"method=\\\"fetchall\\\", ) for idx, elem in enumerate(result): result[idx][0] = (\",\n \"= { \\\"cov\\\": {}, \\\"pearson\\\": {}, \\\"spearman\\\": {}, \\\"spearmand\\\": {},\",\n \"(sauv[elem] - sauv[\\\"approx_50%\\\"]) / ( 1.4826 * sauv[\\\"mad\\\"] ) elif\",\n \"\\\"\\\"\\\" check_types([(\\\"pat\\\", pat, [str])]) return self.apply( func=\\\"REGEXP_COUNT({}, '{}')\\\".format(\\\"{}\\\", pat.replace(\\\"'\\\", \\\"''\\\"))\",\n \"with user defined Encoding. vDataFrame[].get_dummies : Encodes the vColumn with\",\n \"as lower bound quantile(alpha) and as upper bound quantile(1-alpha) if\",\n \"= \\\"SELECT {}, MIN(ord) AS ord, SUM(1 - {}) AS\",\n \"\\\\ / / /\\\\ ___\\\\ /\\\\ __ \\\\ /\\\\ \\\\\",\n \"-------- vDataFrame.topk : Returns the vColumn most occurent elements. \\\"\\\"\\\"\",\n \"str : vColumn alias. catalog, dict : Catalog of pre-computed\",\n \"{}) AS _verticapy_row_nb_ FROM {} WHERE {} IS NOT NULL)\",\n \"be sliced using the floor of the slicing instead of\",\n \"in range(max_floor): self.transformations += [(\\\"{}\\\", self.ctype(), self.category())] self.transformations += [(new_column,\",\n \"Also -------- vDataFrame[].decode : Encodes the vColumn with a user\",\n \"of the vColumn based on an aggregation. \\\"\\\"\\\" check_types( [\",\n \"be used as categorical (No h will be picked or\",\n \"{}, COUNT(*) AS _verticapy_cnt_, 100 * COUNT(*) / {} AS\",\n \"float])]) return self.apply(func=\\\"ROUND({}, {})\\\".format(\\\"{}\\\", n)) # ---# def sem(self): \\\"\\\"\\\"\",\n \"result = result.values[self.alias] elif (method == \\\"cat_stats\\\") and (numcol !=\",\n \"of the different transformations. Each transformation must be similar to\",\n \"1) k: int, optional The integer k of the 'topk'\",\n \"conj = \\\"s were \\\" if total > 1 else\",\n \"picked or computed) ax: Matplotlib axes object, optional The axes\",\n \"split_value FROM (SELECT split_value, MAX(weighted_information_gain) FROM ({}) VERTICAPY_SUBTABLE WHERE split_value\",\n \"percents. Parameters ---------- k: int, optional Number of most occurent\",\n \"a user-specified rule. Parameters ---------- val: int/float/str, optional Value to\",\n \"( 1.4826 * sauv[\\\"mad\\\"] ) elif method == \\\"zscore\\\": self.catalog[elem]\",\n \"query_result = executeSQL( query=query, title=\\\"Computing the distinct categories of {}.\\\".format(self.alias),\",\n \"ax=ax, **style_kwds, ) # ---# def std(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates\",\n \"\\\"NULL\\\" if mean_1_alpha == None: mean_alpha = \\\"NULL\\\" self.apply( func=\\\"(CASE\",\n \"the upper bound itself. Parameters ---------- lower: float, optional Lower\",\n \"method '{}'.\\\".format( self.alias, method ) ) else: raise TypeError(\\\"The vColumn\",\n \"- {})\\\".format( \\\"{}\\\", cmin, \\\"NULLIFZERO\\\" if (nullifzero) else \\\"\\\", cmax,\",\n \"n: int = 10): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns the n smallest\",\n \"std See Also -------- vDataFrame.aggregate : Computes the vDataFrame input\",\n \"trigonometric sine sinh : hyperbolic sine sqrt : arithmetic square\",\n \"the input vColumns. \\\"\\\"\\\" if isinstance(cat_priority, str) or not (isinstance(cat_priority,\",\n \"a user-defined encoding. Parameters ---------- argv: object Any amount of\",\n \"to the input type. \\\"\\\"\\\" check_types([(\\\"dtype\\\", dtype, [str])]) try: query\",\n \"ax.legend( custom_lines, columns, title=by, loc=\\\"center left\\\", bbox_to_anchor=[1, 0.5], ) ax.set_xlabel(self.alias)\",\n \"if isinstance(by, str): by = [by] check_types( [ (\\\"method\\\", method,\",\n \"self.parent.format_colnames(of) from verticapy.plot import pie return pie( self, method, of,\",\n \"from the different categories to [0, n - 1] (n\",\n \"the different categories to [0, n - 1] (n being\",\n \"self.apply(func=\\\"{} * ({})\\\".format(\\\"{}\\\", x)) # ---# def nlargest(self, n: int\",\n \"result], \\\"percent\\\": [float(round(item[2], 3)) for item in result], } return\",\n \"Forest model parameters used to compute the best splits when\",\n \"[ (\\\"{}\\\", self.ctype(), self.category()) ] self.parent[copy_name].transformations += [(func, ctype, category)]\",\n \"int/float/str, optional Value to use to impute the vColumn. method:\",\n \"h, \\\"{}\\\", h, h, h, floor_end ), \\\"varchar\\\", \\\"text\\\", )\",\n \"split_value IS NOT NULL GROUP BY 1 ORDER BY 2\",\n \"Uses the threshold instead of the 'alpha' parameter. alpha: float,\",\n \"function on a specific vColumn. \\\"\\\"\\\" return self.parent.aggregate(func=func, columns=[self.alias]).transpose() agg\",\n \"quantile(1-alpha) will be dropped. Returns ------- vDataFrame self.parent See Also\",\n \"cardinality). Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].decode :\",\n \"[str]), (\\\"max_cardinality\\\", max_cardinality, [int, float]), (\\\"h\\\", h, [int, float]), (\\\"pie_type\\\",\",\n \"self.parent.__genSQL__(), self.alias, self.alias, p_alpha, self.alias, self.alias, p_1_alpha, ) mean_alpha, mean_1_alpha\",\n \"number of elements. same_width : Computes regular width bins. smart\",\n \"float]), (\\\"nbins\\\", nbins, [int, float]), (\\\"h\\\", h, [int, float]), ]\",\n \"self.alias, \\\", \\\".join(by) ), ) if return_trans: return \\\"({} -\",\n \"Forest with 20 trees and a maximum depth of 10.\",\n \"a limit). Parameters ---------- limit: int, optional Number of elements\",\n \"------- vDataFrame self.parent See Also -------- vDataFrame[].slice : Slices the\",\n \"density function. Increasing this parameter will increase the precision but\",\n \"MAX = MIN !\\\".format( self.alias ) warnings.warn(warning_message, Warning) return self\",\n \"a response column to find the most relevant interval to\",\n \"The vColumn to use to compute the aggregation. max_cardinality: int,\",\n \"max_cardinality: int = 6, numcol: str = \\\"\\\" ): \\\"\\\"\\\"\",\n \"3rd. area: bool, optional If set to True, draw an\",\n \"lower, lower) if (isinstance(lower, (float, int))) else \\\"\\\" ) upper_when\",\n \"categories of the vColumn. Returns ------- list Distinct caterogies of\",\n \"to solve this issue.\\\" ) self.add_copy(new_name) parent = self.drop(add_history=False) parent.__add_to_history__(\",\n \") # ---# def apply_fun(self, func: str, x: float =\",\n \"*args): \\\"\\\"\\\" --------------------------------------------------------------------------- Looks if some specific records are in\",\n \"/ ( sauv[\\\"max\\\"] - sauv[\\\"min\\\"] ) except: pass if method\",\n \"of decimal places sign : arithmetic sign sin : trigonometric\",\n \"will be stored in the vDataFrame history. Returns ------- vDataFrame\",\n \"val = self.avg() elif fun == \\\"MEDIAN\\\": val = self.median()\",\n \"dtype: str): \\\"\\\"\\\" --------------------------------------------------------------------------- Converts the vColumn to the input\",\n \"self.transformations = [elem for elem in copy_trans] for elem in\",\n \"datetime.datetime, datetime.date]), (\\\"end_date\\\", end_date, [str, datetime.datetime, datetime.date]), (\\\"area\\\", area, [bool]),\",\n \"name. \\\\u26A0 Warning : SQL code generation will be slower\",\n \"bool, optional If set to True, draw an Area Plot.\",\n \"category. In this case, the parameter 'numcol' must be defined.\",\n \"== 0: nullifzero = 0 cmin, cmax = self.aggregate([\\\"min\\\", \\\"max\\\"]).values[self.alias]\",\n \"be closed on the right. Returns ------- vDataFrame self.parent See\",\n \"__len__(self): return int(self.count()) # ---# def __nonzero__(self): return self.count() >\",\n \"the License for the specific language governing permissions and #\",\n \"8, \\\"nbins\\\": 100}) model.set_params(RFmodel_params) parameters = model.get_params() try: model.fit(tmp_view_name, [self.alias],\",\n \"mean_alpha, \\\"{}\\\", p_1_alpha, mean_1_alpha, \\\"{}\\\" ) ) return self.parent #\",\n \"information, see: https://geopandas.readthedocs.io/en/latest/docs/reference/api/ geopandas.GeoDataFrame.plot.html Returns ------- ax Matplotlib axes object\",\n \"x, [int, float])]) if self.isdate(): return self.apply(func=\\\"TIMESTAMPADD(SECOND, {}, {})\\\".format(x, \\\"{}\\\"))\",\n \"\\\\_/|_|(_||| # / # ____________ ______ # / __ `\\\\\",\n \": hyperbolic sine sqrt : arithmetic square root tan :\",\n \"str, optional Numerical vColumn to use when the parameter method\",\n \"vDataFrame[].discretize : Discretizes the vColumn. vDataFrame[].get_dummies : Encodes the vColumn\",\n \"and 1 that represents the quantile. For example: 0.25 represents\",\n \"Number of digits to keep after the comma. Returns -------\",\n \"= {}).\\\".format(self.alias, y) result = to_tablesample(query, title=title) result.values[\\\"index\\\"] += [\\\"total\\\"]\",\n \"float]), (\\\"h\\\", h, [int, float]), (\\\"pie_type\\\", pie_type, [\\\"auto\\\", \\\"donut\\\", \\\"rose\\\"]),\",\n \"\\\"{}\\\\nThe vColumn {} can not be converted to {}\\\".format( e,\",\n \"or isinstance(val, float): category, ctype = \\\"float\\\", \\\"float\\\" elif method\",\n \"self.catalog[elem] = catalog[elem] # ---# def __getitem__(self, index): if isinstance(index,\",\n \"[(\\\"{}\\\", self.ctype(), self.category())] self.transformations += [(new_column, ctype, category)] try: sauv\",\n \"n == 1: try: result = executeSQL( \\\"SELECT {}, MIN({}),\",\n \"= 0 for elem in by: if len(self.parent[elem].transformations) > max_floor:\",\n \": trigonometric inverse tangent cbrt : cube root ceil :\",\n \"ax=None, **style_kwds, ): \\\"\\\"\\\" --------------------------------------------------------------------------- Draws the range plot of\",\n \"input element to the vColumn. Parameters ---------- x: float If\",\n \"precision but will also increase the time of the learning\",\n \"title=title) # ---# def normalize( self, method: str = \\\"zscore\\\",\",\n \"self, method: str = \\\"auto\\\", max_cardinality: int = 6, numcol:\",\n \"aggregation. max_cardinality: int, optional Maximum number of the vColumn distinct\",\n \"The bandwidth of the kernel. kernel: str, optional The method\",\n \"(h) or h <= 0: if nbins <= 0: h\",\n \"self.category() == \\\"float\\\" else \\\"\\\" if index < 0: index\",\n \"using a mean encoding with {} as Response Column.\\\".format( self.alias,\",\n \"True, NULL values will not be considered during the computation.\",\n \"\\\"round\\\", \\\"sign\\\", \\\"sin\\\", \\\"sinh\\\", \\\"sqrt\\\", \\\"tan\\\", \\\"tanh\\\", ], ), (\\\"x\\\",\",\n \"Classifier otherwise. Example: Write {\\\"n_estimators\\\": 20, \\\"max_depth\\\": 10} to train\",\n \"raise QueryError( \\\"{}\\\\nError when applying the func 'x -> {}'\",\n \"column) )[self.alias].density( bandwidth=bandwidth, kernel=kernel, nbins=nbins, xlim=(xmin, xmax), ax=ax, **updated_dict(param, style_kwds,\",\n \"a copy of the vColumn. \\\"\\\"\\\" check_types([(\\\"new_name\\\", new_name, [str])]) old_name\",\n \"changing the parameter 'new_name', you'll be able to solve this\",\n \"response ) ) if verticapy.options[\\\"print_info\\\"]: print(\\\"The mean encoding was successfully\",\n \"input vColumns using the input method. Parameters ---------- method: str,\",\n \"/ {}({} - {})\\\".format( \\\"{}\\\", cmin, \\\"NULLIFZERO\\\" if (nullifzero) else\",\n \"--------------------------------------------------------------------------- Aggregates the vColumn using 'sum'. Returns ------- float sum\",\n \"\\\"robust_zscore\\\", \\\"minmax\\\"]), (\\\"by\\\", by, [list]), (\\\"return_trans\\\", return_trans, [bool]), ] )\",\n \"vColumns used in the partition. return_trans: bool, optimal If set\",\n \"elem: self.catalog[elem] = sauv[elem] elif elem == None: self.catalog[elem] =\",\n \"optional List of the different transformations. Each transformation must be\",\n \"check_types( [ ( \\\"func\\\", func, [ \\\"abs\\\", \\\"acos\\\", \\\"asin\\\", \\\"atan\\\",\",\n \"for the discretization (must be > 1) k: int, optional\",\n \"\\\"\\\"\\\" --------------------------------------------------------------------------- Adds the input element to the vColumn. Parameters\",\n \"be closed. If set to True, the intervals will be\",\n \"Draws the vColumn Density Plot. Parameters ---------- by: str, optional\",\n \"[int, float])]) if n == 1: pre_comp = self.parent.__get_catalog_value__(self.alias, \\\"top\\\")\",\n \"+ prefix_sep.replace('\\\"', \\\"_\\\") ) n = 1 if drop_first else\",\n \"parameter breaks must be equal to the length of parameter\",\n \"and machine learning features. It supports the # entire data\",\n \"self.alias, p_alpha, self.alias, self.alias, p_1_alpha, ) mean_alpha, mean_1_alpha = [\",\n \"the vColumn is boolean. vDataFrame[].isdate : Returns True if the\",\n \"{} > {})\\\".format( self.parent.__genSQL__(), self.alias, self.alias, p_alpha, self.alias, self.alias, p_1_alpha,\",\n \"for elem in result if elem[1] != None ] ),\",\n \"[int, float]), ] ) if of: self.parent.are_namecols_in(of) of = self.parent.format_colnames(of)\",\n \"Aggregates the vColumn using 'avg' (Average). Returns ------- float average\",\n \"USING PARAMETERS percentile = 0.25) AS 'approx_25%', APPROXIMATE_PERCENTILE ({3}{4} USING\",\n \"_verticapy_cnt_, 100 * COUNT(*) / {} AS percent FROM {}{}\",\n \"self.alias, self.transformations = ( parent, alias, [elem for elem in\",\n \"from verticapy.plot import boxplot return boxplot(self, by, h, max_cardinality, cat_priority,\",\n \"uses a ‘pipeline’ mechanism to sequentialize # data transformation operations,\",\n \"int(total) conj = \\\"s were \\\" if total > 1\",\n \"# distributed under the License is distributed on an \\\"AS\",\n \"be transformed. Parameters ---------- field: str The field to extract.\",\n \"object, optional The axes to plot on. **style_kwds Any optional\",\n \"20, \\\"max_depth\\\": 8, \\\"nbins\\\": 100}) model.set_params(RFmodel_params) parameters = model.get_params() try:\",\n \"transform the vColumn. abs : absolute value acos : trigonometric\",\n \"of, max_cardinality, nbins, h, ax=ax, **style_kwds) # ---# def boxplot(\",\n \"If set to True, the intervals will be closed on\",\n \"self.parent See Also -------- vDataFrame.add_copy : Creates a copy of\",\n \"mode (most occurent element). 0ifnull : 0 when the vColumn\",\n \"int, optional Cardinality threshold to use to determine if the\",\n \"elements in the vColumn. \\\"\\\"\\\" check_types([(\\\"n\\\", n, [int, float])]) query\",\n \") query += [lp + tmp_query + rp] query =\",\n \"variables.\\\" ) warnings.warn(warning_message, Warning) else: distinct_elements = self.distinct() expr =\",\n \": Looks if some specific records are in the vDataFrame.\",\n \"= max( len(self.parent[column].transformations), max_floor ) except: pass max_floor -= len(self.transformations)\",\n \"be numerical\\\" ) cast = \\\"::int\\\" if (self.parent[numcol].isbool()) else \\\"\\\"\",\n \"= \\\"COALESCE({}, LAST_VALUE({} IGNORE NULLS) OVER ({} ORDER BY {}))\\\".format(\",\n \") fd = max(2.0 * (vColumn_075 - vColumn_025) / (count)\",\n \"to True, the approximate cardinality is returned. By setting this\",\n \"------- vDataFrame The vDataFrame of the search. See Also --------\",\n \"kwargs[\\\"agg\\\"], self.parent.__genSQL__(), self.alias, ) query_result = executeSQL( query=query, title=\\\"Computing the\",\n \"ISOYEAR / MICROSECONDS / MILLENNIUM / MILLISECONDS / MINUTE /\",\n \"kernel. logistic : Logistic kernel. sigmoid : Sigmoid kernel. silverman\",\n \"the vColumn by transforming the values lesser than the lower\",\n \"bool, optional If set to True, the record will be\",\n \"in kwargs): kwargs[\\\"legend\\\"] = True if not (\\\"figsize\\\" in kwargs):\",\n \"Computes the vColumn descriptive statistics. \\\"\\\"\\\" check_types([(\\\"k\\\", k, [int, float]),\",\n \"self.parent.__genSQL__(), by[0], ), title=\\\"Computing the different categories {} to normalize.\\\".format(\",\n \"-------- vDataFrame.case_when : Creates a new feature by evaluating some\",\n \"gen_tmp_name(schema=schema, name=\\\"kde\\\") if isinstance(xlim, (tuple, list)): xlim_tmp = [xlim] else:\",\n \"For more information, see utilities.tablesample. See Also -------- vDataFrame.analytic :\",\n \"iv_woe.\\\".format(y) ) self.parent[y].distinct() trans = self.discretize( method=\\\"same_width\\\" if self.isnum() else\",\n \"values = { \\\"index\\\": [item[0] for item in result], \\\"count\\\":\",\n \"BY _verticapy_cnt_ DESC {}\\\".format( bin_spatial_to_str(self.category(), self.alias), self.alias, self.parent.shape()[0], self.parent.__genSQL__(), dropna,\",\n \"\\\"mode\\\") and (val == None): val = self.mode(dropna=True) if val\",\n \"{}, \\\"cramer\\\": {}, \\\"biserial\\\": {}, \\\"regr_avgx\\\": {}, \\\"regr_avgy\\\": {}, \\\"regr_count\\\":\",\n \"float, optional Lower bound. upper: float, optional Upper bound. Returns\",\n \"if len(args) > 0: column = args[0] elif \\\"column\\\" in\",\n \"The vColumn '{}' was normalized with the method '{}'.\\\".format( self.alias,\",\n \"executeSQL( query=query, title=\\\"Computing the quantiles of {}.\\\".format(self.alias), method=\\\"fetchrow\\\", ) if\",\n \"( \\\"start_date\\\", start_date, [str, datetime.datetime, datetime.date, int, float], ), (\",\n \"self mad, med = self.aggregate([\\\"mad\\\", \\\"approx_median\\\"]).values[self.alias] mad *= 1.4826 if\",\n \"if self.isnum() and method == \\\"smart\\\": schema = verticapy.options[\\\"temp_schema\\\"] if\",\n \"/ # / / # \\\\ / # \\\\ /\",\n \"str = \\\"\\\", return_enum_trans: bool = False, ): \\\"\\\"\\\" ---------------------------------------------------------------------------\",\n \"---------- n: int, optional Offset. Returns ------- tablesample An object\",\n \"plot. The other categories will be filtered. ax: Matplotlib axes\",\n \"([0, 1], [1, 0]) or self.isbool(): all_new_features = [] prefix\",\n \"bool, optional Uses numbers as suffix instead of the vColumns\",\n \"vDataFrame.boxplot : Draws the Box Plot of the input vColumns.\",\n \"\\\"topk\\\"], ), (\\\"return_enum_trans\\\", return_enum_trans, [bool]), ] ) method = method.lower()\",\n \"\\\"\\\"\\\" --------------------------------------------------------------------------- Extracts a specific TS field from the vColumn\",\n \"= 8, cat_priority: list = [], ax=None, **style_kwds, ): \\\"\\\"\\\"\",\n \"5). of: str, optional The vColumn to use to compute\",\n \"AS count, 100 * COUNT({1}) / {2} AS percent, AVG({3}{4})\",\n \"\\\"\\\"\\\" pre_comp = self.parent.__get_catalog_value__(self.alias, \\\"store_usage\\\") if pre_comp != \\\"VERTICAPY_NOT_PRECOMPUTED\\\": return\",\n \"vDataFrame[].describe : Computes the vColumn descriptive statistics. \\\"\\\"\\\" return self.describe(method=\\\"categorical\\\",\",\n \"\\\"SELECT {}::{} AS {} FROM {} WHERE {} IS NOT\",\n \"values: for i in range(len(values[elem])): if isinstance(values[elem][i], decimal.Decimal): values[elem][i] =\",\n \"{} IS NOT NULL GROUP BY 1) x ORDER BY\",\n \"optional Labels used to name the new categories. If empty,\",\n \"RandomForestRegressor, ) drop(tmp_model_name, method=\\\"model\\\") if self.parent[response].category() == \\\"float\\\": model =\",\n \"\\\", \\\".join(by) ) else: new_column = \\\"COALESCE({}, {}({}) OVER (PARTITION\",\n \"a Robust Z-Score - The MAD is null !\\\".format( self.alias\",\n \"\\\\ / / / # \\\\ / / / #\",\n \"\\\"\\\"\\\" check_types([(\\\"new_name\\\", new_name, [str])]) old_name = quote_ident(self.alias) new_name = new_name.replace('\\\"',\",\n \"h, [int, float]), ] ) if of: self.parent.are_namecols_in(of) of =\",\n \"equal frequency histogram bins.\\\", method=\\\"fetchall\\\", ) result = [elem[0] for\",\n \"-------- vDataFrame.astype : Converts the vColumns to the input type.\",\n \"---------- approx: bool, optional If set to True, the approximate\",\n \"pre_comp assert n >= 1, ParameterError(\\\"Parameter 'n' must be greater\",\n \"abs(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Applies the absolute value function to the\",\n \"the vDataFrame input aggregations. \\\"\\\"\\\" return self.aggregate([\\\"variance\\\"]).values[self.alias][0] variance = var\",\n \"\\\" for i in range(1, n): trans += \\\"WHEN {}\",\n \"store usage. See Also -------- vDataFrame.expected_store_usage : Returns the vDataFrame\",\n \"x) return self.apply(func=expr) # ---# def astype(self, dtype: str): \\\"\\\"\\\"\",\n \"self.category() == \\\"int\\\": best_h = max(math.floor(best_h), 1) return best_h #\",\n \"{}, \\\"regr_syy\\\": {}, } for elem in catalog: self.catalog[elem] =\",\n \"ord, SUM(1 - {}) AS non_events, SUM({}) AS events FROM\",\n \"round(self, n: int): \\\"\\\"\\\" --------------------------------------------------------------------------- Rounds the vColumn by keeping\",\n \"categories. If empty, names will be generated. include_lowest: bool, optional\",\n \"distinct_count, is_numeric, is_date = ( self.nunique(), self.isnum(), self.isdate(), ) if\",\n \"/ ISODOW / ISOWEEK / ISOYEAR / MICROSECONDS / MILLENNIUM\",\n \"PARAMETERS percentile = 0.5) AS 'approx_50%', APPROXIMATE_PERCENTILE ({3}{4} USING PARAMETERS\",\n \"] ) start_or_end = \\\"START\\\" if (start) else \\\"END\\\" return\",\n \"Parameters ---------- func: str, Function in pure SQL used to\",\n \"method == \\\"topk\\\": assert k >= 2, ParameterError( \\\"Parameter 'k'\",\n \"in ffill|pad|bfill|backfill then 'order_by' must be a list of at\",\n \"\\\", \\\".join(by) ), ) else: cmax, cmin = ( \\\"MAX({})\",\n \"* IQR / n ** (1 / 3)] sturges :\",\n \"self.parent, columns, method, of, max_cardinality, h, ax=ax, **style_kwds, ) #\",\n \"See Also -------- vDataFrame.aggregate : Computes the vDataFrame input aggregations.\",\n \"self.parent.__genSQL__(), self.alias ) executeSQL(query, title=\\\"Testing the Type casting.\\\") self.transformations +=\",\n \"able to look at the final transformation. Returns ------- vDataFrame\",\n \"using the input Name. Returns ------- vDataFrame self.parent See Also\",\n \"if \\\"count\\\" in sauv: self.catalog[\\\"count\\\"] = sauv[\\\"count\\\"] self.catalog[\\\"percent\\\"] = (\",\n \"|. # |_)\\\\/ |_)(_|(_|| \\\\_/|_|(_||| # / # ____________ ______\",\n \"bool = True, ): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using\",\n \"\\\"\\\"\\\" --------------------------------------------------------------------------- Draws the box plot of the vColumn. Parameters\",\n \"in result if elem[2] != None ] ), ) executeSQL(\",\n \"AS verticapy_agg FROM {} WHERE {} IS NOT NULL GROUP\",\n \"\\\"float\\\" elif method == \\\"0ifnull\\\": category, ctype = \\\"int\\\", \\\"bool\\\"\",\n \": Replaces the regular expression matches in each of the\",\n \"under the License is distributed on an \\\"AS IS\\\" BASIS,\",\n \"Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].apply : Applies\",\n \"elements. Parameters ---------- n: int, optional Offset. Returns ------- tablesample\",\n \"kernel=kernel, nbins=nbins, xlim=xlim_tmp, store=False, ) try: result = model.fit(self.parent.__genSQL__(), [self.alias]).plot(\",\n \"for the discretization. topk : Keeps the topk most frequent\",\n \"== \\\"zscore\\\": self.catalog[elem] = (sauv[elem] - sauv[\\\"mean\\\"]) / sauv[ \\\"std\\\"\",\n \"(\\\"h\\\", h, [int, float]), (\\\"nbins\\\", nbins, [int, float]), ] )\",\n \"the NULL value. winsorize : Clips the vColumn using as\",\n \"self.discretize( method=\\\"same_width\\\" if self.isnum() else \\\"topk\\\", nbins=nbins, k=nbins, new_category=\\\"Others\\\", return_enum_trans=True,\",\n \"self.aggregate([\\\"mad\\\", \\\"approx_median\\\"]).values[self.alias] mad *= 1.4826 if mad != 0: if\",\n \"mean skewness : skewness sum : sum std : standard\",\n \"/ / # \\\\ / / / # \\\\ /\",\n \"the regular expression in each record of the vColumn. vDataFrame[].extract\",\n \"type. \\\"\\\"\\\" return self.transformations[-1][2] # ---# def clip(self, lower=None, upper=None):\",\n \"+= [(new_column, ctype, category)] try: sauv = {} for elem\",\n \"\\\\ \\\\_____\\\\ \\\\ \\\\_____\\\\ \\\\ \\\\_____\\\\ \\\\ \\\\_____\\\\ \\\\ \\\\_\\\\\",\n \"plot function. For more information, see: https://geopandas.readthedocs.io/en/latest/docs/reference/api/ geopandas.GeoDataFrame.plot.html Returns -------\",\n \"= \\\"NULL\\\" if mean_1_alpha == None: mean_alpha = \\\"NULL\\\" self.apply(\",\n \"the MIN and the MAX. MAX = MIN !\\\".format( self.alias\",\n \"def slice(self, length: int, unit: str = \\\"second\\\", start: bool\",\n \"the vColumn category is date. \\\"\\\"\\\" return self.category() in (\\\"float\\\",\",\n \"vColumn alias. transformations: list, optional List of the different transformations.\",\n \"int = 30): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns the k most occurent\",\n \"if labels: label = labels[idx] else: label = f\\\"{close_l}{first_elem};{second_elem}{close_r}\\\" conditions\",\n \"/ / # | \\\\/ / / / # |______\",\n \"self.parent.__genSQL__(), self.alias, self.alias, n ) title = \\\"Reads {} {}\",\n \"new_name: str The new vColumn alias. Returns ------- vDataFrame self.parent\",\n \"self.parent.__genSQL__() ), print_time_sql=False, ) except: cmax, cmin = ( \\\"MAX({})\",\n \"self.parent.format_colnames(ts) from verticapy.plot import range_curve_vdf return range_curve_vdf( self, ts, q,\",\n \"# ---# def discretize( self, method: str = \\\"auto\\\", h:\",\n \"(\\\"h\\\", h, [int, float]), (\\\"cat_priority\\\", cat_priority, [list]), ] ) if\",\n \"= self.min() table = \\\"(SELECT DATEDIFF('second', '{}'::timestamp, {}) AS {}\",\n \"function to the vColumn. Parameters ---------- func: str Function to\",\n \"\\\"LIMIT {}\\\".format(k) dropna = \\\" WHERE {} IS NOT NULL\\\".format(self.alias)\",\n \"vDataFrame input aggregations. \\\"\\\"\\\" return self.aggregate([\\\"max\\\"]).values[self.alias][0] # ---# def mean_encode(self,\",\n \"dtype, self.alias, self.parent.__genSQL__(), self.alias ) executeSQL(query, title=\\\"Testing the Type casting.\\\")\",\n \"2) + 2\\\". copy_name: str, optional If not empty, a\",\n \"of at least one element to use to order the\",\n \"column = kwargs[\\\"column\\\"] else: check = False if check: self.parent.are_namecols_in(column)\",\n \"each of the vColumn records. vDataFrame[].str_count : Computes the number\",\n \"({})\\\".format( \\\", \\\".join([\\\"1\\\"] + nth_elems + [str(count)]) ) query =\",\n \"One vDataFrame can have multiple children vColumns whereas one vColumn\",\n \"\\\"\\\"\\\" --------------------------------------------------------------------------- Encodes the vColumn using a user-defined encoding. Parameters\",\n \"h, h, h, floor_end ), \\\"varchar\\\", \\\"text\\\", ) else: trans\",\n \"OVER (PARTITION BY {}))\\\".format( \\\"{}\\\", fun, \\\"{}\\\", \\\", \\\".join(by) )\",\n \"len(result) trans = \\\"(CASE \\\" for i in range(1, n):\",\n \"License. # # |_ |~) _ _| _ /~\\\\ _\",\n \"the vDataFrame input aggregations. \\\"\\\"\\\" return self.aggregate([\\\"mad\\\"]).values[self.alias][0] # ---# def\",\n \"if of: self.parent.are_namecols_in(of) of = self.parent.format_colnames(of) from verticapy.plot import hist\",\n \"(No h will be picked or computed) nbins: int, optional\",\n \"pt_events) * ZEROIFNULL(LN(pt_non_events / NULLIFZERO(pt_events))) END AS iv FROM ({})\",\n \"self.alias for idx in range(len(breaks) - 1): first_elem, second_elem =\",\n \"\\\"\\\"\\\" --------------------------------------------------------------------------- Returns a part of the vColumn (delimited by\",\n \"\\\")\\\" else: lp, rp = \\\"\\\", \\\"\\\" for category in\",\n \"vColumn using the mean encoding of a response. \\\"\\\"\\\" check_types(\",\n \"( 100 * sauv[\\\"count\\\"] / self.parent.shape()[0] ) for elem in\",\n \"= self.parent.__get_catalog_value__(self.alias, \\\"store_usage\\\") if pre_comp != \\\"VERTICAPY_NOT_PRECOMPUTED\\\": return pre_comp store_usage\",\n \"+= ( \\\"UNION ALL (SELECT 'Others', SUM(count) FROM (SELECT COUNT(*)\",\n \"then 'order_by' must be a list of at least one\",\n \"the method 'smart'.\\\" ) self.parent.are_namecols_in(response) response = self.parent.format_colnames(response) drop(tmp_view_name, method=\\\"view\\\")\",\n \": variance Other aggregations could work if it is part\",\n \"simplify several processes with its abstractions. Parameters ---------- alias: str\",\n \"med = self.aggregate([\\\"mad\\\", \\\"approx_median\\\"]).values[self.alias] mad *= 1.4826 if mad !=\",\n \"Catalog of pre-computed aggregations. parent, vDataFrame : Parent of the\",\n \"the vColumn {} named {} was added to the vDataFrame.\\\".format(\",\n \"inverse cosine asin : trigonometric inverse sine atan : trigonometric\",\n \"return self.category() in (\\\"float\\\", \\\"int\\\") # ---# def iv_woe(self, y:\",\n \"it is used to compute other vColumns. Parameters ---------- add_history:\",\n \"of the vColumn. vDataFrame[].extract : Extracts the regular expression in\",\n \"category)] try: sauv = {} for elem in self.catalog: sauv[elem]\",\n \"set to True, the approximate median is returned. By setting\",\n \"plot_median, ax=ax, **style_kwds, ) # ---# def rename(self, new_name: str):\",\n \"vColumn. Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].apply :\",\n \"WHERE {} IS NOT NULL GROUP BY {} ORDER BY\",\n \"result[\\\"avg\\\"][0], result[\\\"std\\\"][0], threshold ) ) else: p_alpha, p_1_alpha = (\",\n \": Computes the vDataFrame input aggregations. \\\"\\\"\\\" return self.quantile(0.5, approx=approx)\",\n \"\\\"\\\") assert not (self.parent.is_colname_in(new_name)), NameError( f\\\"A vColumn has already the\",\n \"/\\\\ ___\\\\ /\\\\ __ \\\\ /\\\\ \\\\ /\\\\ \\\\/\\\\ \\\\\",\n \"= 100 self.parent.__add_to_history__( \\\"[Label Encoding]: Label Encoding was applied to\",\n \"\\\\ \\\\ \\\\ \\\\-./\\\\ \\\\ \\\\ \\\\ \\\\-. \\\\ #\",\n \"the License. # You may obtain a copy of the\",\n \"2, TypeError( \\\"vColumn {} must be binary to use iv_woe.\\\".format(y)\",\n \"during the computation. max_cardinality: int, optional Cardinality threshold to use\",\n \"(ex: AVG(column1) + 5). ax: Matplotlib axes object, optional The\",\n \"plot( self, ts: str, by: str = \\\"\\\", start_date: Union[str,\",\n \"decimal.Decimal): top = float(top) self.parent.__update_catalog__( {\\\"index\\\": [\\\"top{}\\\".format(n)], self.alias: [top]} )\",\n \"] ) if by: self.parent.are_namecols_in(by) by = self.parent.format_colnames(by) columns =\",\n \"self.alias, self.parent.__genSQL__(), self.alias, self.alias, self.alias, ) else: query = \\\"SELECT\",\n \"h, h, \\\"{}\\\", h, h, h, floor_end ), \\\"varchar\\\", \\\"text\\\",\",\n \"self.parent.__genSQL__(), self.alias, ) query_result = executeSQL( query=query, title=\\\"Computing the distinct\",\n \"float])]) if offset < 0: offset = max(0, self.parent.shape()[0] -\",\n \"**style_kwds) # ---# def boxplot( self, by: str = \\\"\\\",\",\n \"= self.drop(add_history=False) parent.__add_to_history__( \\\"[Rename]: The vColumn {} was renamed '{}'.\\\".format(old_name,\",\n \"= len(self.parent[response].transformations) - len( self.transformations ) for k in range(max_floor):\",\n \"+ \\\" END\\\" self.apply(func=expr) # ---# def ctype(self): \\\"\\\"\\\" ---------------------------------------------------------------------------\",\n \"like (date, datetime, timestamp...) or numerical. q: tuple, optional Tuple\",\n \"i + 1] ... ELSE argv[n] END Returns ------- vDataFrame\",\n \"func) or ( re.search( re.compile(\\\"\\\\\\\\b{}\\\\\\\\b\\\".format(column.replace('\\\"', \\\"\\\"))), func ) ): max_floor\",\n \"vColumn (only if the vColumn type is date like). The\",\n \"* i] THEN argv[2 * i + 1] ... END\",\n \"\\\"\\\", by: list = [], order_by: list = [], ):\",\n \"optional vColumns used in the partition. return_trans: bool, optimal If\",\n \"(elem[0] == None) else \\\"'{}'\\\".format(str(elem[0]).replace(\\\"'\\\", \\\"''\\\")) ) result[idx][1] = \\\"NULL\\\"\",\n \"(\\\"return_trans\\\", return_trans, [bool]), ] ) method = method.lower() self.parent.are_namecols_in(by) by\",\n \"Slice size unit. For example, it can be 'minute' 'hour'...\",\n \"RF Regressor will be trained if the response is numerical\",\n \"in (\\\"mean\\\", \\\"median\\\") or isinstance(val, float): category, ctype = \\\"float\\\",\",\n \"check = False if check: self.parent.are_namecols_in(column) column = self.parent.format_colnames(column) columns\",\n \"TypeError( \\\"The column 'numcol' must be numerical\\\" ) cast =\",\n \"the dummies ({name}).\\\\n\\\" \\\"It can be the result of using\",\n \"None: warning_message = \\\"The vColumn {} has no mode (only\",\n \"BY {0} ORDER BY COUNT(*)\\\" \\\" DESC OFFSET {1}) VERTICAPY_SUBTABLE)\",\n \"vColumn using the input functions. Parameters ---------- func: list List\",\n \"check_types( [ (\\\"ts\\\", ts, [str]), (\\\"by\\\", by, [str]), (\\\"start_date\\\", start_date,\",\n \"(\\\"upper\\\", upper, [float, int])]) assert (lower != None) or (upper\",\n \"= [self.alias] check = True if len(args) > 0: column\",\n \"= quote_ident(name.replace('\\\"', \\\"_\\\")) assert name.replace('\\\"', \\\"\\\"), EmptyParameter( \\\"The parameter 'name'\",\n \"already the alias {new_name}.\\\\nBy changing the parameter 'new_name', you'll be\",\n \"of the vColumns 1 and 2 bars. It is only\",\n \"in the vDataFrame. \\\"\\\"\\\" if isinstance(val, str) or not (isinstance(val,\",\n \"upper bound quantile(1-alpha) if 'use_threshold' is set to False else\",\n \"------- ax Matplotlib axes object See Also -------- vDataFrame.bar :\",\n \"None: new_column = \\\"COALESCE({}, '{}')\\\".format(\\\"{}\\\", val) elif expr: new_column =\",\n \"Returns the vColumn memory usage. Returns ------- float vColumn memory\",\n \"numcol: str, optional Numerical vColumn to use when the parameter\",\n \"x: float = 2): \\\"\\\"\\\" --------------------------------------------------------------------------- Applies a default function\",\n \"title=title, ) tail.count = self.parent.shape()[0] tail.offset = offset tail.dtype[self.alias] =\",\n \"self.catalog[\\\"median\\\"] = 0 self.catalog[\\\"mad\\\"] = 1 / 1.4826 elif method\",\n \"self.apply(func=st.decode(str_sql(\\\"{}\\\"), *argv)) # ---# def density( self, by: str =\",\n \"datetime.datetime, datetime.date, int, float], ), ( \\\"end_date\\\", end_date, [str, datetime.datetime,\",\n \"of: str = \\\"\\\", max_cardinality: Union[int, tuple] = (6, 6),\",\n \"\\\"prod\\\": 0, }, ) setattr(self.parent, name, new_vColumn) setattr(self.parent, name.replace('\\\"', \\\"\\\"),\",\n \"see utilities.tablesample. See Also -------- vDataFrame.analytic : Adds a new\",\n \"self.parent.get_columns(), 0 for column in all_cols: try: if (quote_ident(column) in\",\n \"width if the vColumn is numerical or of type date\",\n \"] ), ) executeSQL( \\\"SELECT {}, {} FROM {} LIMIT\",\n \"of the vColumn. vDataFrame[].str_slice : Slices the vColumn. \\\"\\\"\\\" check_types([(\\\"to_replace\\\",\",\n \"{}({})\\\".format( self.alias, avg, \\\"NULLIFZERO\\\" if (nullifzero) else \\\"\\\", stddev )\",\n \"Computes the vDataFrame Global Outliers. \\\"\\\"\\\" if isinstance(by, str): by\",\n \"or greater than quantile(1-alpha) will be filled. Returns ------- vDataFrame\",\n \"vDataFrame[].decode : Encodes the vColumn with user defined Encoding. vDataFrame[].discretize\",\n \"a time series rule. \\\"\\\"\\\" return self.apply(func=\\\"DATE_PART('{}', {})\\\".format(field, \\\"{}\\\")) #\",\n \"query_result] else: result = ( self.parent.describe( method=\\\"numerical\\\", columns=[self.alias], unique=False )\",\n \"Dummies]: One hot encoder was applied to the vColumn {}\\\\n{}\",\n \"# data around for processing, VerticaPy brings the logic to\",\n \"\\\"float\\\", \\\"float\\\", ) ] else: warning_message = \\\"Can not normalize\",\n \"used to cut the vColumn. labels: list, optional Labels used\",\n \"/ {2} AS percent, AVG({3}{4}) AS mean, STDDEV({3}{4}) AS std,\",\n \"Freedman Diaconis and Sturges. freedman_diaconis : Freedman Diaconis [2 *\",\n \"Computes the vDataFrame input aggregations. \\\"\\\"\\\" return self.aggregate([\\\"stddev\\\"]).values[self.alias][0] stddev =\",\n \"\\\"''\\\") ) ) # ---# def str_slice(self, start: int, step:\",\n \"--------------------------------------------------------------------------- Aggregates the vColumn using multiple statistical aggregations: min, max,\",\n \"(PARTITION BY {})\\\".format( self.alias, \\\", \\\".join(by) ), ) if return_trans:\",\n \"if pre_comp != \\\"VERTICAPY_NOT_PRECOMPUTED\\\": if not (dropna) and (pre_comp !=\",\n \"method when first preparing your data. Parameters ---------- new_name: str\",\n \"- The Standard Deviation is null !\\\".format( self.alias ) warnings.warn(warning_message,\",\n \"except: pass max_floor -= len(self.transformations) if copy_name: self.add_copy(name=copy_name) for k\",\n \"if distinct_count > max_cardinality: query += ( \\\"UNION ALL (SELECT\",\n \"Sum of the vColumn 'of'. q% : q Quantile of\",\n \"setattr(self.parent, name.replace('\\\"', \\\"\\\"), new_vColumn) self.parent._VERTICAPY_VARIABLES_[\\\"columns\\\"] += [name] all_new_features += [name]\",\n \"6, nbins: int = 0, h: float = 0, ax=None,\",\n \"the vColumn. \\\"\\\"\\\" check_types([(\\\"n\\\", n, [int, float])]) query = \\\"SELECT\",\n \"the tail of the vColumn. Parameters ---------- limit: int, optional\",\n \"of elements to skip. Returns ------- tablesample An object containing\",\n \"Parameters ---------- ts: str TS (Time Series) vColumn to use\",\n \"AVG(column1) + 5). ax: Matplotlib axes object, optional The axes\",\n \"vDataFrame input aggregations. \\\"\\\"\\\" return self.aggregate([\\\"avg\\\"]).values[self.alias][0] mean = avg #\",\n \"\\\"{}\\\")) else: return self.apply(func=\\\"{} + ({})\\\".format(\\\"{}\\\", x)) # ---# def\",\n \"False rose = True if pie_type == \\\"rose\\\" else False\",\n \"bool = True, use_numbers_as_suffix: bool = False, ): \\\"\\\"\\\" ---------------------------------------------------------------------------\",\n \"= \\\"public\\\" tmp_view_name = gen_tmp_name(schema=schema, name=\\\"view\\\") tmp_model_name = gen_tmp_name(schema=schema, name=\\\"model\\\")\",\n \"PARAMETERS model_name = '{}', tree_id = {}, format = 'tabular'))\\\".format(\",\n \"[2 * IQR / n ** (1 / 3)] sturges\",\n \"(ORDER BY {}) AS _verticapy_row_nb_ FROM {} WHERE {} IS\",\n \"using the MIN and the MAX. MAX = MIN !\\\".format(\",\n \"ax=None, **style_kwds, ): \\\"\\\"\\\" --------------------------------------------------------------------------- Draws the spider plot of\",\n \"in (1, None), ValueError( \\\"vColumn doesn't allow slicing having steps\",\n \"0.9) AS 'approx_90%', MAX({3}{4}) AS max FROM vdf_table\\\"\\\"\\\".format( category, self.alias,\",\n \"\\\"\\\"\\\" --------------------------------------------------------------------------- Filters the vDataFrame where the vColumn is missing.\",\n \"(\\\"by\\\", by, [str]), (\\\"start_date\\\", start_date, [str, datetime.datetime, datetime.date]), (\\\"end_date\\\", end_date,\",\n \"+ rp] query = \\\"WITH vdf_table AS (SELECT * FROM\",\n \"index = result.values[\\\"index\\\"] result = result.values[self.alias] elif (method == \\\"cat_stats\\\")\",\n \"def isnum(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns True if the vColumn is\",\n \"aggregate # ---# def apply(self, func: str, copy_name: str =\",\n \") if use_threshold: result = self.aggregate(func=[\\\"std\\\", \\\"avg\\\"]).transpose().values self.parent.filter( \\\"ABS({} -\",\n \"name = gen_tmp_name(schema=schema, name=\\\"kde\\\") if isinstance(xlim, (tuple, list)): xlim_tmp =\",\n \"\\\"acos\\\", \\\"asin\\\", \\\"atan\\\", \\\"cbrt\\\", \\\"ceil\\\", \\\"cos\\\", \\\"cosh\\\", \\\"cot\\\", \\\"exp\\\", \\\"floor\\\",\",\n \"See Also -------- vDataFrame.filter: Filters the data using the input\",\n \"AND {column} {op2} '{second_elem}' THEN '{label}'\\\" ] expr = \\\"CASE\",\n \"[\\\"auto\\\", \\\"smart\\\", \\\"same_width\\\", \\\"same_freq\\\", \\\"topk\\\"], ), (\\\"return_enum_trans\\\", return_enum_trans, [bool]), ]\",\n \") return parent # ---# def round(self, n: int): \\\"\\\"\\\"\",\n \"\\\\/_/ \\\\/_/ # # # ---# class vColumn(str_sql): \\\"\\\"\\\" ---------------------------------------------------------------------------\",\n \"query_result for item in sublist] # ---# def div(self, x:\",\n \"method=\\\"fetchall\\\", ) result = [elem[0] for elem in result] elif\",\n \"list(args) check_types([(\\\"val\\\", val, [list])]) val = {self.alias: val} return self.parent.isin(val)\",\n \"assert index.step in (1, None), ValueError( \\\"vColumn doesn't allow slicing\",\n \"self.alias, ), \\\"apply_test_feature\\\", ) except: ctype = get_data_types( \\\"SELECT {}\",\n \"categorical (No h will be picked or computed) nbins: int,\",\n \"\\\"CASE WHEN \\\" + \\\" WHEN \\\".join(conditions) + \\\" END\\\"\",\n \"collections.abc import Iterable from typing import Union # VerticaPy Modules\",\n \"\\\"x\\\"), ) ) return self.parent except Exception as e: raise\",\n \"*argv)) # ---# def density( self, by: str = \\\"\\\",\",\n \"str): order_by = [order_by] check_types( [ ( \\\"method\\\", method, [\",\n \"life cycle, uses a ‘pipeline’ mechanism to sequentialize # data\",\n \"# / __ `\\\\ / / # | \\\\/ /\",\n \"smallest elements in the vColumn. Parameters ---------- n: int, optional\",\n \"\\\"\\\"))), func ) ): max_floor = max( len(self.parent[column].transformations), max_floor )\",\n \"categorical vColumns. bfill : Back Propagation of the next element\",\n \"[val] val += list(args) check_types([(\\\"val\\\", val, [list])]) val = {self.alias:\",\n \"TS (Time Series) vColumn to use to order the data.\",\n \"elements, please use a method in zscore|minmax\\\" warnings.warn(warning_message, Warning) return\",\n \"each of the vColumn record by an input value. The\",\n \"to use to convert the vColumn. If this parameter is\",\n \"filling.\\\".format(e)) if total > 0: try: if \\\"count\\\" in sauv:\",\n \"vColumn. Parameters ---------- by: str, optional vColumn to use to\",\n \"elements will be gathered together to create a new category\",\n \"(only missing values).\\\\nNothing was filled.\\\".format( self.alias ) warnings.warn(warning_message, Warning) return\",\n \"of {} (response = {}).\\\".format(self.alias, y) result = to_tablesample(query, title=title)\",\n \"(1.4826 * mad) minmax : Normalization using the MinMax (min\",\n \"self.parent # ---# def fillna( self, val=None, method: str =\",\n \"parameter is used for testing purpose. Returns ------- vDataFrame self.parent\",\n \"/ (count) ** (1.0 / 3.0), 1e-99) if method.lower() ==\",\n \"\\\"_\\\") .replace(\\\"'\\\", \\\"_\\\") ) expr = \\\"DECODE({}, '{}', 1, 0)\\\".format(\",\n \"[\\\"DECODE({}\\\"] text_info = \\\"\\\\n\\\" for k in range(len(distinct_elements)): expr +=\",\n \"set to True, the approximate cardinality is returned. By setting\",\n \"can be seen as one column of that relation. vColumns\",\n \"prefix_sep, [str]), (\\\"drop_first\\\", drop_first, [bool]), (\\\"use_numbers_as_suffix\\\", use_numbers_as_suffix, [bool]), ] )\",\n \"relation, a vColumn can be seen as one column of\",\n \"self.apply(func=\\\"TIMESTAMPADD(SECOND, -({}), {})\\\".format(x, \\\"{}\\\")) else: return self.apply(func=\\\"{} - ({})\\\".format(\\\"{}\\\", x))\",\n \"vColumn with a user defined Encoding. vDataFrame[].discretize : Discretizes the\",\n \"h.\\\", method=\\\"fetchrow\\\", ) count, vColumn_min, vColumn_025, vColumn_075, vColumn_max = result\",\n \"sub(self, x: float): \\\"\\\"\\\" --------------------------------------------------------------------------- Subtracts the input element from\",\n \": Computes the vDataFrame input aggregations. \\\"\\\"\\\" check_types([(\\\"dropna\\\", dropna, [bool]),\",\n \"---# def __getitem__(self, index): if isinstance(index, slice): assert index.step in\",\n \"\\\"UNION ALL (SELECT 'Others', SUM(count) FROM (SELECT COUNT(*) AS count\\\"\",\n \"\\\"\\\"\\\" return self.iloc(limit=limit) # ---# def hist( self, method: str\",\n \"index_stop += self.parent.shape()[0] limit = index_stop - index_start if limit\",\n \"Forest.\\\", method=\\\"fetchall\\\", ) result = [elem[0] for elem in result]\",\n \"return_trans: bool, optimal If set to True, the method will\",\n \"around for processing, VerticaPy brings the logic to the data.\",\n \"Propagation of the first element (Constant Interpolation). mean : Average.\",\n \"limit, offset, ), title=title, ) tail.count = self.parent.shape()[0] tail.offset =\",\n \"trans = self.discretize( method=\\\"same_width\\\" if self.isnum() else \\\"topk\\\", nbins=nbins, k=nbins,\",\n \"vDataFrame self.parent See Also -------- vDataFrame[].dropna : Drops the vColumn\",\n \"\\\"START\\\" if (start) else \\\"END\\\" return self.apply( func=\\\"TIME_SLICE({}, {}, '{}',\",\n \"spider as spider_plot return spider_plot( self.parent, columns, method, of, max_cardinality,\",\n \"number of vColumn distinct elements to be used as categorical.\",\n \"one of the following: date / int / float /\",\n \"{} THEN '[{};{}]' \\\".format( \\\"{}\\\", result[i - 1], result[i], result[i\",\n \"{})\\\".format(response, \\\"{}\\\"), \\\"int\\\", \\\"float\\\") ] self.parent.__update_catalog__(erase=True, columns=[self.alias]) self.parent.__add_to_history__( \\\"[Mean Encode]:\",\n \"independent variable in relation to the dependent variable. Parameters ----------\",\n \"events / NULLIFZERO(SUM(events) OVER ()) AS pt_events FROM ({}) x\\\".format(\",\n \"self.apply(func=\\\"ROUND({}, {})\\\".format(\\\"{}\\\", n)) # ---# def sem(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates\",\n \"self, method: str = \\\"auto\\\", h: float = 0, nbins:\",\n \"top{} categories of {}.\\\".format( k if k > 0 else\",\n \"\\\\_____\\\\ \\\\ \\\\_____\\\\ \\\\ \\\\_____\\\\ \\\\ \\\\_\\\\ \\\\ \\\\_\\\\ \\\\\",\n \"1 ORDER BY 2 DESC LIMIT {}) VERTICAPY_SUBTABLE ORDER BY\",\n \"check_types([(\\\"dtype\\\", dtype, [str])]) try: query = \\\"SELECT {}::{} AS {}\",\n \"vDataFrame[].label_encode : Encodes the vColumn with Label Encoding. vDataFrame[].mean_encode :\",\n \"mean encoding was successfully done.\\\") return self.parent # ---# def\",\n \"None ] ), ) cmax = \\\"DECODE({}, {}, NULL)\\\".format( by[0],\",\n \"return. dropna: bool, optional If set to True, NULL values\",\n \"occurent elements to return. dropna: bool, optional If set to\",\n \"# # |_ |~) _ _| _ /~\\\\ _ |.\",\n \"/ /\\\\ ___\\\\ /\\\\ __ \\\\ /\\\\ \\\\ /\\\\ \\\\/\\\\\",\n \"Function in pure SQL used to transform the vColumn. The\",\n \"column in self.parent._VERTICAPY_VARIABLES_[\\\"columns\\\"] ] force_columns.remove(self.alias) executeSQL( \\\"SELECT * FROM {}\",\n \"isinstance(by, str): by = [by] if isinstance(order_by, str): order_by =\",\n \"# |_ |~) _ _| _ /~\\\\ _ |. #\",\n \"the vColumn. Parameters ---------- by: str, optional vColumn to use\",\n \"missing. Returns ------- vDataFrame self.parent See Also -------- vDataFrame.filter: Filters\",\n \"{})\\\".format( self.alias, \\\", \\\".join(by) ), \\\"MIN({}) OVER (PARTITION BY {})\\\".format(\",\n \"use to sort the data when using TS methods. Returns\",\n \"float])]) assert x != 0, ValueError(\\\"Division by 0 is forbidden\",\n \"\\\"\\\"\\\"(SELECT {0} || '', COUNT(*) FROM vdf_table GROUP BY {0}\",\n \"[], order_by: list = [], ): \\\"\\\"\\\" --------------------------------------------------------------------------- Fills missing\",\n \"+= [ \\\"'{}', {}\\\".format(str(distinct_elements[k]).replace(\\\"'\\\", \\\"''\\\"), k) ] text_info += \\\"\\\\t{}\",\n \"---# def str_slice(self, start: int, step: int): \\\"\\\"\\\" --------------------------------------------------------------------------- Slices\",\n \"sturges : Sturges [CEIL(log2(n)) + 1] Returns ------- float optimal\",\n \"first preparing your data. Parameters ---------- new_name: str The new\",\n \"this parameter will increase the precision but will also increase\",\n \"/ # \\\\ / / / # \\\\_______/ / /\",\n \"function's performance can drastically decrease. Returns ------- float/str median See\",\n \"max_cardinality: int, optional Cardinality threshold to use to determine if\",\n \"] ) self.parent.are_namecols_in(ts) ts = self.parent.format_colnames(ts) if by: self.parent.are_namecols_in(by) by\",\n \"vColumn using an input 'quantile'. Parameters ---------- x: float A\",\n \") values = to_tablesample(query, title=title).values elif ( ((distinct_count < max_cardinality\",\n \"for item in query_result] index = [\\\"unique\\\", \\\"count\\\"] + [item[0]\",\n \"based on an aggregation. \\\"\\\"\\\" if isinstance(pie_type, str): pie_type =\",\n \"\\\"\\\"\\\" return self.aggregate(func=[\\\"prod\\\"]).values[self.alias][0] prod = product # ---# def quantile(self,\",\n \"order the data. The vColumn type must be date like\",\n \"self.parent.__add_to_history__( \\\"[Apply]: The vColumn '{}' was transformed with the func\",\n \"= avg # ---# def bar( self, method: str =\",\n \"bool, optional Drops the first dummy to avoid the creation\",\n \": trigonometric tangent tanh : hyperbolic tangent x: int/float, optional\",\n \"this method when first preparing your data. Parameters ---------- new_name:\",\n \"transformations = self.transformations + [(expr, \\\"bool\\\", \\\"int\\\")] new_vColumn = vColumn(\",\n \"[], self.alias for idx in range(len(breaks) - 1): first_elem, second_elem\",\n \"def discretize( self, method: str = \\\"auto\\\", h: float =\",\n \"most relevant interval to use for the discretization. topk :\",\n \"order_by: list = [], ): \\\"\\\"\\\" --------------------------------------------------------------------------- Fills missing elements\",\n \"the precision but will also increase the time of the\",\n \"start_date, end_date, area, step, ax=ax, **style_kwds, ) # ---# def\",\n \"If set to True, the approximate quantile is returned. By\",\n \"the right. Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].apply\",\n \"freedman_diaconis : Freedman Diaconis [2 * IQR / n **\",\n \"str_count(self, pat: str): \\\"\\\"\\\" --------------------------------------------------------------------------- Computes the number of matches\",\n \"self.alias, len(all_new_features), conj, \\\", \\\".join(all_new_features) ) + \\\".\\\" ) return\",\n \"/\\\\ __ \\\\ /\\\\ \\\\ /\\\\ \\\\/\\\\ \\\\ /\\\\ \\\"-./\",\n \"Number of nbins. If empty, an optimized number of nbins\",\n \"AS (SELECT * FROM {}) (SELECT AVG({}) FROM vdf_table WHERE\",\n \"the upper bound to the upper bound itself. Parameters ----------\",\n \"the vColumn 'of'. sum : Sum of the vColumn 'of'.\",\n \"q: tuple, optional Tuple including the 2 quantiles used to\",\n \"COUNT(*) FROM vdf_table GROUP BY {0} ORDER BY COUNT(*) DESC\",\n \"null : Replaces the outliers by the NULL value. winsorize\",\n \"scoring phases. xlim: tuple, optional Set the x limits of\",\n \"{}))\\\".format( \\\"{}\\\", fun, \\\"{}\\\", \\\", \\\".join(by) ) else: new_column =\",\n \"end_date, [str, datetime.datetime, datetime.date, int, float], ), (\\\"plot_median\\\", plot_median, [bool]),\",\n \"second_elem = breaks[idx], breaks[idx + 1] if right: op1, op2,\",\n \"computed) h: float, optional Interval width of the bar. If\",\n \"[ Line2D( [0], [0], color=updated_dict(param, style_kwds, idx)[\\\"color\\\"], lw=4, ), ]\",\n \"Fouad are in the vColumn. You can write the following\",\n \"(\\\"color\\\" in kwargs): from verticapy.plot import gen_colors kwargs[\\\"color\\\"] = gen_colors()[0]\",\n \"{}) UNION ALL (SELECT AVG({}) FROM vdf_table WHERE {} >\",\n \"\\\"median\\\", \\\"ffill\\\", \\\"pad\\\", \\\"bfill\\\", \\\"backfill\\\", ], ), (\\\"expr\\\", expr, [str]),\",\n \"cosine cot : trigonometric cotangent exp : exponential function floor\",\n \") ) if verticapy.options[\\\"print_info\\\"]: print(\\\"The mean encoding was successfully done.\\\")\",\n \"function floor : value down to the next whole number\",\n \"1 that represents the quantile. For example: 0.25 represents Q1.\",\n \"vColumn. vDataFrame[].label_encode : Encodes the vColumn with Label Encoding. vDataFrame[].get_dummies\",\n \"isinstance(order_by, str): order_by = [order_by] check_types( [ ( \\\"method\\\", method,\",\n \"vdf_table WHERE {0} IS NOT NULL GROUP BY {0} ORDER\",\n \"---# def __nonzero__(self): return self.count() > 0 # ---# def\",\n \"vDataFrame.aggregate : Computes the vDataFrame input aggregations. \\\"\\\"\\\" return self.aggregate([\\\"sem\\\"]).values[self.alias][0]\",\n \"mode : most occurent element percent : percent of non-missing\",\n \"---# def count(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using 'count'\",\n \"verticapy from verticapy.utilities import * from verticapy.toolbox import * from\",\n \"the input type. Parameters ---------- dtype: str New type. Returns\",\n \"records by an input value. \\\"\\\"\\\" check_types([(\\\"start\\\", start, [int, float]),\",\n \"item in self.transformations], catalog=self.catalog, ) setattr(self.parent, name, new_vColumn) setattr(self.parent, name[1:-1],\",\n \"use \\\"POWER({}, 2) + 2\\\". copy_name: str, optional If not\",\n \"replace. value: str, optional New value. Returns ------- vDataFrame self.parent\",\n \"object Any amount of expressions. The expression generated will look\",\n \"+= [(expr, \\\"int\\\", \\\"int\\\")] self.parent.__update_catalog__(erase=True, columns=[self.alias]) self.catalog[\\\"count\\\"] = self.parent.shape()[0] self.catalog[\\\"percent\\\"]\",\n \"For more information, see utilities.tablesample. See Also -------- vDataFrame[].nsmallest :\",\n \"the 2 quantiles used to draw the Plot. start_date: str\",\n \"[int, float]), (\\\"numcol\\\", numcol, [str]), ] ) method = method.lower()\",\n \"drop(tmp_view_name, method=\\\"view\\\") drop(tmp_model_name, method=\\\"model\\\") result = [self.min()] + result +\",\n \"( 100 * sauv[\\\"count\\\"] / self.parent.shape()[0] ) except: pass self.parent.__add_to_history__(\",\n \"\\\"public\\\" tmp_view_name = gen_tmp_name(schema=schema, name=\\\"view\\\") tmp_model_name = gen_tmp_name(schema=schema, name=\\\"model\\\") assert\",\n \"of moving # data around for processing, VerticaPy brings the\",\n \": Combination of Freedman Diaconis and Sturges. freedman_diaconis : Freedman\",\n \"gen_colors() if not xlim: xmin = self.min() xmax = self.max()\",\n \"== \\\"cat_stats\\\") and (numcol != \\\"\\\"): numcol = self.parent.format_colnames(numcol) assert\",\n \"x)) # ---# def add_copy(self, name: str): \\\"\\\"\\\" --------------------------------------------------------------------------- Adds\",\n \"1\\\".format( self.alias, self.alias, self.parent.__genSQL__(), where, self.alias, n ), title=\\\"Computing the\",\n \"= \\\"\\\"\\\"SELECT '{0}' AS 'index', COUNT({1}) AS count, 100 *\",\n \"Filters the vDataFrame where the vColumn is missing. Returns -------\",\n \"if method not in [\\\"mode\\\", \\\"0ifnull\\\"]: max_floor = 0 all_partition\",\n \"else \\\"\\\", self.alias ), method=\\\"fetchall\\\", ) values = { \\\"index\\\":\",\n \"or not (labels), ParameterError( \\\"Length of parameter breaks must be\",\n \"def memory_usage(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns the vColumn memory usage. Returns\",\n \"= \\\"density\\\", of: str = \\\"\\\", max_cardinality: int = 6,\",\n \"fun, \\\"{}\\\", \\\", \\\".join(by) ) else: new_column = \\\"COALESCE({}, {}({})\",\n \"specific language governing permissions and # limitations under the License.\",\n \"FROM {}\\\".format( bin_spatial_to_str(self.category(), self.alias), self.parent.__genSQL__(), ), title=\\\"Computing the Store Usage\",\n \"to use to fill the vColumn outliers. mean : Replaces\",\n \"tmp_model_name = gen_tmp_name(schema=schema, name=\\\"model\\\") assert nbins >= 2, ParameterError( \\\"Parameter\",\n \"float sem See Also -------- vDataFrame.aggregate : Computes the vDataFrame\",\n \"Exception as e: raise QueryError( \\\"{}\\\\nError when applying the func\",\n \"\\\"cot\\\", \\\"exp\\\", \\\"floor\\\", \\\"ln\\\", \\\"log\\\", \\\"log10\\\", \\\"mod\\\", \\\"pow\\\", \\\"round\\\", \\\"sign\\\",\",\n \"[float, int]), (\\\"upper\\\", upper, [float, int])]) assert (lower != None)\",\n \"you want to normalize by grouping by elements, please use\",\n \"preparing your data. Parameters ---------- new_name: str The new vColumn\",\n \"object containing the result. For more information, see utilities.tablesample. See\",\n \") model.drop() return result except: model.drop() raise # ---# def\",\n \"\\\"\\\"\\\" --------------------------------------------------------------------------- Returns the vColumn DB type. Returns ------- str\",\n \"---------- start: int Start of the slicing. step: int Size\",\n \": arithmetic square root tan : trigonometric tangent tanh :\",\n \"------- vDataFrame self.parent See Also -------- vDataFrame.filter: Filters the data\",\n \"kwargs): kwargs[\\\"legend\\\"] = True if not (\\\"figsize\\\" in kwargs): kwargs[\\\"figsize\\\"]\",\n \"the Bar Chart of the input vColumns based on an\",\n \"...), the parameter 'x' will represent the number of seconds,\",\n \"self.isdate(), TypeError( \\\"cut only works on numerical / date-like vColumns.\\\"\",\n \"aggregation. h: int/float/tuple, optional Interval width of the vColumns 1\",\n \"------- bool True if the vColumn is numerical. See Also\",\n \"self.count() if method not in [\\\"mode\\\", \\\"0ifnull\\\"]: max_floor = 0\",\n \"lesser than quantile(alpha) or greater than quantile(1-alpha) will be dropped.\",\n \"input aggregations. \\\"\\\"\\\" return self.aggregate([\\\"sum\\\"]).values[self.alias][0] # ---# def tail(self, limit:\",\n \"column for each vColumn category. In this case, the parameter\",\n \"must not be empty\\\" ) assert not (self.parent.is_colname_in(name)), NameError( f\\\"A\",\n \"__setattr__(self, attr, val): self.__dict__[attr] = val # # Methods #\",\n \"cmax, cmin = ( \\\"MAX({}) OVER (PARTITION BY {})\\\".format( self.alias,\",\n \"* i] THEN argv[2 * i + 1] ... ELSE\",\n \"timestamp...) or numerical. q: tuple, optional Tuple including the 2\",\n \"enough values to compute the Equal Frequency discretization\\\" ) total,\",\n \"WHERE {} IS NOT NULL LIMIT 20\\\".format( self.alias, dtype, self.alias,\",\n \"Uses popular numerical aggregations during the computation. max_cardinality: int, optional\",\n \"error of the mean skewness : skewness sum : sum\",\n \"type iqr : interquartile range kurtosis : kurtosis jb :\",\n \"+= [\\\"total\\\"] result.values[\\\"non_events\\\"] += [sum(result[\\\"non_events\\\"])] result.values[\\\"events\\\"] += [sum(result[\\\"events\\\"])] result.values[\\\"pt_non_events\\\"] +=\",\n \"method == \\\"same_freq\\\") or ( self.isnum() and method == \\\"smart\\\"\",\n \"different transformations. Each transformation must be similar to the following:\",\n \"= {}, format = 'tabular'))\\\".format( tmp_model_name, i ) for i\",\n \"using 'aad' (Average Absolute Deviation). Returns ------- float aad See\",\n \"float]), ] ) if of: self.parent.are_namecols_in(of) of = self.parent.format_colnames(of) from\",\n \"conditions. vDataFrame[].discretize : Discretizes the vColumn. vDataFrame[].label_encode : Encodes the\",\n \"applied to the vColumn {} using the following mapping:{}\\\".format( self.alias,\",\n \"0: warning_message = \\\"Can not normalize {} using the MIN\",\n \"h: float = 0, pie_type: str = \\\"auto\\\", ax=None, **style_kwds,\",\n \"number of matches for the regular expression in each record\",\n \"int, optional Offset. Returns ------- tablesample An object containing the\",\n \"= [], self.alias for idx in range(len(breaks) - 1): first_elem,\",\n \"None) else str(elem[1]) new_column = \\\"COALESCE({}, DECODE({}, {}, NULL))\\\".format( \\\"{}\\\",\",\n \"try: result = executeSQL( \\\"SELECT {}, AVG({}), STDDEV({}) FROM {}\",\n \"self.transformations += [(\\\"{}\\\", self.ctype(), self.category())] self.transformations += [(func, ctype, category)]\",\n \"range : difference between the max and the min sem\",\n \"topk : kth most occurent element (ex: top1 for the\",\n \"vColumn and creating a copy with the specified name. \\\\u26A0\",\n \"axes object See Also -------- vDataFrame[].hist : Draws the histogram\",\n \"self.quantile(0.5, approx=approx) # ---# def memory_usage(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns the\",\n \"self, threshold: float = 4.0, use_threshold: bool = True, alpha:\",\n \"to solve this \\\" \\\"issue.\\\" ) for k in range(len(distinct_elements)\",\n \"prefix: str = \\\"\\\", prefix_sep: str = \\\"_\\\", drop_first: bool\",\n \"[ column for column in self.parent._VERTICAPY_VARIABLES_[\\\"columns\\\"] ] force_columns.remove(self.alias) executeSQL( \\\"SELECT\",\n \"vDataFrame[].hist : Draws the histogram of the vColumn based on\",\n \"= gen_cmap()[0] else: if not (\\\"color\\\" in kwargs): from verticapy.plot\",\n \"{}{}) VERTICAPY_SUBTABLE\\\".format( self.alias, self.parent.__genSQL__(), self.parent.__get_last_order_by__(), index_start, limit, ) return vDataFrameSQL(query)\",\n \"vColumn type must be date like (date, datetime, timestamp...) or\",\n \"parent.__add_to_history__( \\\"[Rename]: The vColumn {} was renamed '{}'.\\\".format(old_name, new_name) )\",\n \"the vColumn descriptive statistics. \\\"\\\"\\\" return self.describe(method=\\\"categorical\\\", max_cardinality=k) # ---#\",\n \"p_1_alpha = ( self.parent.quantile([alpha, 1 - alpha], [self.alias]) .transpose() .values[self.alias]\",\n \"Copyright [2018-2022] Micro Focus or one of its affiliates. #\",\n \"numerical for Normalization\\\") return self.parent # ---# def nsmallest(self, n:\",\n \"vColumn has already the alias of one of the dummies\",\n \"\\\"Length of parameter breaks must be equal to the length\",\n \"{}) VERTICAPY_SUBTABLE ORDER BY split_value::float\\\".format( \\\" UNION ALL \\\".join(query), nbins\",\n \"), title=\\\"Computing the different categories {} to normalize.\\\".format( by[0] ),\",\n \"(start) else \\\"END\\\" return self.apply( func=\\\"TIME_SLICE({}, {}, '{}', '{}')\\\".format( \\\"{}\\\",\",\n \"sauv[elem] return self.parent # ---# def geo_plot(self, *args, **kwargs): \\\"\\\"\\\"\",\n \"List of values used to cut the vColumn. labels: list,\",\n \"bins used for the discretization (must be > 1) k:\",\n \"use to impute the vColumn. method: dict, optional Method to\",\n \"avg, stddev = self.aggregate([\\\"avg\\\", \\\"std\\\"]).values[self.alias] if stddev == 0: warning_message\",\n \"== 1) and (self.parent[by[0]].nunique() < 50): try: if fun ==\",\n \"nbins: int = 0, h: float = 0, ax=None, **style_kwds,\",\n \"a new category : 'Others'. cat_priority: list, optional List of\",\n \"most occurent element (ex: top1 for the mode) topk_percent :\",\n \"= executeSQL( query=query, title=\\\"Computing the distinct categories of {}.\\\".format(self.alias), method=\\\"fetchall\\\",\",\n \"encoding was successfully done.\\\") return self.parent # ---# def median(\",\n \"\\\"approx_unique\\\": 2, \\\"prod\\\": 0, }, ) setattr(self.parent, name, new_vColumn) setattr(self.parent,\",\n \"x -> x^2 + 2 use \\\"POWER({}, 2) + 2\\\".\",\n \") executeSQL(query, title=\\\"Testing the Type casting.\\\") self.transformations += [ (\",\n \"== \\\"int\\\") else \\\"\\\" if (h > 1) or (self.category()\",\n \"_____________ / / # \\\\ / / / # \\\\\",\n \"the vColumn 'of'. q% : q Quantile of the vColumn\",\n \"6) if self.category() == \\\"int\\\": h = int(max(math.floor(h), 1)) floor_end\",\n \"result[idx][1] = \\\"NULL\\\" if (elem[1] == None) else str(elem[1]) new_column\",\n \"new vColumn alias. Returns ------- vDataFrame self.parent See Also --------\",\n \"regular expression in each record of the vColumn. vDataFrame[].str_slice :\",\n \"The vColumn {} was renamed '{}'.\\\".format(old_name, new_name) ) return parent\",\n \"self.apply(func=\\\"TIMESTAMPADD(SECOND, {}, {})\\\".format(x, \\\"{}\\\")) else: return self.apply(func=\\\"{} + ({})\\\".format(\\\"{}\\\", x))\",\n \"[] while total < int(float(count / int(nbins))) * int(nbins): nth_elems\",\n \"# ---# def describe( self, method: str = \\\"auto\\\", max_cardinality:\",\n \"min) / (max - min) by: list, optional vColumns used\",\n \"assert (lower != None) or (upper != None), ParameterError( \\\"At\",\n \"to 'numerical' if the vColumn is numerical , 'categorical' otherwise.\",\n \"elements to be used as categorical (No h will be\",\n \"as categorical. numcol: str, optional Numerical vColumn to use when\",\n \"\\\"COALESCE({}, {})\\\".format(\\\"{}\\\", val) elif (len(by) == 1) and (self.parent[by[0]].nunique() <\",\n \"Applies a function to the input vColumn. \\\"\\\"\\\" return self.apply(func=\\\"ABS({})\\\")\",\n \"response. \\\"\\\"\\\" check_types( [ (\\\"prefix\\\", prefix, [str]), (\\\"prefix_sep\\\", prefix_sep, [str]),\",\n \"result. For more information, see utilities.tablesample. See Also -------- vDataFrame[].nsmallest\",\n \"A RF Regressor will be trained if the response is\",\n \": Uses method 'same_width' for numerical vColumns, cast the other\",\n \"the vColumn is boolean. See Also -------- vDataFrame[].isdate : Returns\",\n \"+ {}{}) || ']'\\\".format( \\\"{}\\\", h, h, \\\"{}\\\", h, h,\",\n \"by: self.parent.are_namecols_in(by) by = self.parent.format_colnames(by) from verticapy.plot import gen_colors from\",\n \"boolean. vDataFrame[].isnum : Returns True if the vColumn is numerical.\",\n \"(method in (\\\"ffill\\\", \\\"pad\\\")) else \\\" DESC\\\" partition_by = (\",\n \"self.isnum() and method == \\\"smart\\\" ): n = len(result) trans\",\n \"self.transformations[-1][1].lower() dtype = ctype # ---# def date_part(self, field: str):\",\n \"most occurent elements. \\\"\\\"\\\" if \\\"agg\\\" not in kwargs: query\",\n \"for elem in catalog: self.catalog[elem] = catalog[elem] # ---# def\",\n \"(prefix) else prefix.replace('\\\"', \\\"_\\\") + prefix_sep.replace('\\\"', \\\"_\\\") ) n =\",\n \"FROM vdf_table WHERE {} < {}) UNION ALL (SELECT AVG({})\",\n \"ParameterError( \\\"Parameter 'nbins' must be greater or equals to 2\",\n \"not (isinstance(cat_priority, Iterable)): cat_priority = [cat_priority] check_types( [ (\\\"by\\\", by,\",\n \"tuple = None, ax=None, **style_kwds, ): \\\"\\\"\\\" --------------------------------------------------------------------------- Draws the\",\n \"\\\"bool\\\", \\\"int\\\")] new_vColumn = vColumn( name, parent=self.parent, transformations=transformations, catalog={ \\\"min\\\":\",\n \"if elem[2] != None else \\\"NULL\\\", ) for elem in\",\n \"[\\\"gaussian\\\", \\\"logistic\\\", \\\"sigmoid\\\", \\\"silverman\\\"]), (\\\"bandwidth\\\", bandwidth, [int, float]), (\\\"nbins\\\", nbins,\",\n \"cmin, cmax = self.aggregate([\\\"min\\\", \\\"max\\\"]).values[self.alias] if cmax - cmin ==\",\n \"if (n == 1) else str(int(n)) if isinstance(top, decimal.Decimal): top\",\n \"\\\\ /\\\\ \\\\/\\\\ \\\\ /\\\\ \\\"-./ \\\\ /\\\\ \\\"-.\\\\ \\\\\",\n \"self.parent if isinstance(val, str): val = val.replace(\\\"'\\\", \\\"''\\\") if val\",\n \"Number of most occurent elements to return. Returns ------- tablesample\",\n \"> 0: warning_message = \\\"The method 'robust_zscore' is available only\",\n \"AS pt_events FROM ({}) x\\\".format( self.alias, query, ) query =\",\n \"where each key corresponds to an aggregation. vColumns will memorize\",\n \"return executeSQL( query=query, title=\\\"Getting the vColumn element.\\\", method=\\\"fetchfirstelem\\\", ) else:\",\n \"ConversionError( \\\"{}\\\\nThe vColumn {} can not be converted to {}\\\".format(\",\n \"index): if isinstance(index, slice): assert index.step in (1, None), ValueError(\",\n \"example: 0.25 represents Q1. approx: bool, optional If set to\",\n \"+= [(\\\"{}\\\", self.ctype(), self.category())] self.transformations += final_transformation sauv = {}\",\n \"n largest vColumn elements. \\\"\\\"\\\" check_types([(\\\"n\\\", n, [int, float])]) query\",\n \"in self.catalog: sauv[elem] = self.catalog[elem] self.parent.__update_catalog__(erase=True, columns=[self.alias]) try: if \\\"count\\\"\",\n \"return self.parent # ---# def aggregate(self, func: list): \\\"\\\"\\\" ---------------------------------------------------------------------------\",\n \"try: if \\\"count\\\" in sauv: self.catalog[\\\"count\\\"] = int(sauv[\\\"count\\\"]) + total\",\n \"bbox_to_anchor=[1, 0.5], ) ax.set_xlabel(self.alias) return ax kernel = kernel.lower() from\",\n \"BY {} DESC LIMIT {}\\\".format( self.parent.__genSQL__(), self.alias, self.alias, n )\",\n \"\\\"\\\", method: str = \\\"density\\\", of: str = \\\"\\\", max_cardinality:\",\n \"\\\"pow\\\", \\\"round\\\"): expr = \\\"{}({})\\\".format(func.upper(), \\\"{}\\\") else: expr = \\\"{}({},\",\n \"copy_name.replace('\\\"', \\\"\\\"), func.replace(\\\"{}\\\", \\\"x\\\"), ) ) else: for k in\",\n \"{})\\\".format(\\\"{}\\\", n)) # ---# def sem(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the\",\n \"float], ), (\\\"plot_median\\\", plot_median, [bool]), ] ) self.parent.are_namecols_in(ts) ts =\",\n \"return the mode of the vColumn. Returns ------- str/float/int vColumn\",\n \"k: int, optional Number of most occurent elements to return.\",\n \"record by an input value. The vColumn will be transformed.\",\n \"vColumn expected store usage. See Also -------- vDataFrame.expected_store_usage : Returns\",\n \"if (elem[0] == None) else \\\"'{}'\\\".format(str(elem[0]).replace(\\\"'\\\", \\\"''\\\")) ) result[idx][1] =\",\n \"elements, how often they occur, and other statistical information. Parameters\",\n \"\\\\/ / / / # |______ / / / #\",\n \"[ item[0] for item in executeSQL( query=query, title=\\\"Computing the average\",\n \"interval to use for the discretization. topk : Keeps the\",\n \"\\\"minmax\\\": if n == 0: nullifzero = 0 cmin, cmax\",\n \"# Modules # # Standard Python Modules import math, re,\",\n \"AS index, non_events, events, pt_non_events, pt_events, CASE WHEN non_events =\",\n \": hyperbolic tangent x: int/float, optional If the function has\",\n \"the vDataFrame input aggregations. \\\"\\\"\\\" return self.aggregate([\\\"count\\\"]).values[self.alias][0] # ---# def\",\n \"For example, time = '03-11-1993' will filter the data when\",\n \"result if elem[2] != None ] ), ) executeSQL( \\\"SELECT\",\n \"== None) else str(elem[1]) new_column = \\\"COALESCE({}, DECODE({}, {}, NULL))\\\".format(\",\n \"if (isinstance(upper, (float, int))) else \\\"\\\" ) func = \\\"(CASE\",\n \"verticapy.plot import boxplot return boxplot(self, by, h, max_cardinality, cat_priority, ax=ax,\",\n \"of parameter 'labels' + 1 or parameter 'labels' must be\",\n \"max_cardinality, cat_priority, ax=ax, **style_kwds) # ---# def category(self): \\\"\\\"\\\" ---------------------------------------------------------------------------\",\n \"is in each of the vColumn records. The vColumn will\",\n \"self.parent See Also -------- vDataFrame.apply : Applies functions to the\",\n \"the One-Hot Encoding algorithm. Parameters ---------- prefix: str, optional Prefix\",\n \"query, cat = [], self.distinct() if len(cat) == 1: lp,\",\n \"of a response. \\\"\\\"\\\" if self.category() in [\\\"date\\\", \\\"float\\\"]: warning_message\",\n \"self.parent.format_colnames(of) from verticapy.plot import bar return bar(self, method, of, max_cardinality,\",\n \"AND {}) THEN {} ELSE NULL END)\\\".format( \\\"{}\\\", p_alpha, p_1_alpha,\",\n \"unit.upper(), start_or_end ) ) # ---# def spider( self, by:\",\n \"more information, see utilities.tablesample. See Also -------- vDataFrame.aggregate : Computes\",\n \"labels, [list]), (\\\"include_lowest\\\", include_lowest, [bool]), (\\\"right\\\", right, [bool]), ] )\",\n \"\\\\ \\\\____ \\\\ \\\\ \\\\/\\\\ \\\\ \\\\ \\\\ \\\\____ \\\\\",\n \"the MinMax (min and max). (x - min) / (max\",\n \"k most occurent elements, how often they occur, and other\",\n \"new_column = \\\"COALESCE({}, {})\\\".format(\\\"{}\\\", val) elif (len(by) == 1) and\",\n \"= quote_ident(self.alias) new_name = new_name.replace('\\\"', \\\"\\\") assert not (self.parent.is_colname_in(new_name)), NameError(\",\n \"parameter will increase the precision but will also increase the\",\n \"except: pass if method == \\\"robust_zscore\\\": self.catalog[\\\"median\\\"] = 0 self.catalog[\\\"mad\\\"]\",\n \"---# def round(self, n: int): \\\"\\\"\\\" --------------------------------------------------------------------------- Rounds the vColumn\",\n \"vColumn 'of'. sum : Sum of the vColumn 'of'. q%\",\n \"method=\\\"model\\\") result = [self.min()] + result + [self.max()] elif method\",\n \"Parameters ---------- add_history: bool, optional If set to True, the\",\n \"re.search( re.compile(\\\"\\\\\\\\b{}\\\\\\\\b\\\".format(column.replace('\\\"', \\\"\\\"))), func ) ): max_floor = max( len(self.parent[column].transformations),\",\n \"transforming the values lesser than the lower bound to the\",\n \"BY COUNT(*)\\\" \\\" DESC OFFSET {1}) VERTICAPY_SUBTABLE) ORDER BY count\",\n \"if pre_comp != \\\"VERTICAPY_NOT_PRECOMPUTED\\\": return pre_comp assert self.isnum() or self.isdate(),\",\n \"AS Q3, MAX({}) AS max FROM {}\\\".format( self.alias, self.alias, self.alias,\",\n \"the different categories to normalize.\\\", method=\\\"fetchall\\\", ) for i in\",\n \"the record will be sliced using the floor of the\",\n \"): \\\"\\\"\\\" --------------------------------------------------------------------------- Draws the range plot of the vColumn.\",\n \"the vColumn. Parameters ---------- x: float If the vColumn type\",\n \"= to_tablesample(query, title=title) result.values[\\\"index\\\"] += [\\\"total\\\"] result.values[\\\"non_events\\\"] += [sum(result[\\\"non_events\\\"])] result.values[\\\"events\\\"]\",\n \"parent and do not apply it. This parameter is very\",\n \"of the vColumn (delimited by an offset and a limit).\",\n \"0 for k in range(len(distinct_elements) - n): name = (\",\n \"verticapy.plot import hist return hist(self, method, of, max_cardinality, nbins, h,\",\n \"where = \\\"WHERE _verticapy_row_nb_ IN ({})\\\".format( \\\", \\\".join([\\\"1\\\"] + nth_elems\",\n \"{}, \\\"pearson\\\": {}, \\\"spearman\\\": {}, \\\"spearmand\\\": {}, \\\"kendall\\\": {}, \\\"cramer\\\":\",\n \"the vColumn records by an input value. \\\"\\\"\\\" check_types([(\\\"start\\\", start,\",\n \"print(\\\"The mean encoding was successfully done.\\\") return self.parent # ---#\",\n \"{} > {} THEN {} ELSE {} END)\\\".format( \\\"{}\\\", p_alpha,\",\n \"title=\\\"Computing the different categories {} to normalize.\\\".format( by[0] ), method=\\\"fetchall\\\",\",\n \"The category will be one of the following: date /\",\n \"i in range(parameters[\\\"n_estimators\\\"]) ] query = \\\"SELECT split_value FROM (SELECT\",\n \"is greater than the threshold, it will be considered as\",\n \"by = self.parent.format_colnames(by) columns = [self.alias, by] else: columns =\",\n \"the next whole number ln : natural logarithm log :\",\n \"if add_history: self.parent.__add_to_history__( \\\"[Drop]: vColumn {} was deleted from the\",\n \"[int, float]), ] ) if func not in (\\\"log\\\", \\\"mod\\\",\",\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)\",\n \"breaks, [list]), (\\\"labels\\\", labels, [list]), (\\\"include_lowest\\\", include_lowest, [bool]), (\\\"right\\\", right,\",\n \"[int, float])]) query = \\\"SELECT * FROM {} WHERE {}\",\n \"= ( \\\"MAX({}) OVER (PARTITION BY {})\\\".format( self.alias, \\\", \\\".join(by)\",\n \"---# def str_extract(self, pat: str): \\\"\\\"\\\" --------------------------------------------------------------------------- Extracts the regular\",\n \"in range(len(values[elem])): if isinstance(values[elem][i], decimal.Decimal): values[elem][i] = float(values[elem][i]) return tablesample(values)\",\n \"------- float mad See Also -------- vDataFrame.aggregate : Computes the\",\n \"self.alias), self.parent.__genSQL__(), self.alias, ), \\\"apply_test_feature\\\", ) category = get_category_from_vertica_type(ctype=ctype) all_cols,\",\n \"values to compute the Equal Frequency discretization\\\" ) total, query,\",\n \"result = self.aggregate([\\\"count\\\", \\\"min\\\", \\\"max\\\"]) index = result.values[\\\"index\\\"] result =\",\n \"self.catalog[\\\"mean\\\"] = 0 self.catalog[\\\"std\\\"] = 1 elif method == \\\"minmax\\\":\",\n \"0 else \\\"\\\", self.alias ), method=\\\"fetchall\\\", ) values = {\",\n \"current axes. ax: Matplotlib axes object, optional The axes to\",\n \"are numerical. Optimized h will be computed if the parameter\",\n \"parameter 'numcol' must be defined. numerical : Uses popular numerical\",\n \"maximum See Also -------- vDataFrame.aggregate : Computes the vDataFrame input\",\n \"average of the response partitioned by the different vColumn categories.\",\n \": value up to the next whole number cos :\",\n \"0 self.catalog[\\\"max\\\"] = 1 self.parent.__add_to_history__( \\\"[Normalize]: The vColumn '{}' was\",\n \"= result.values[\\\"index\\\"] result = result.values[self.alias] elif (method == \\\"cat_stats\\\") and\",\n \"Input number. Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].apply\",\n \"the information will be stored in the vDataFrame history. Returns\",\n \"missing values).\\\\nNothing was filled.\\\".format( self.alias ) warnings.warn(warning_message, Warning) return self.parent\",\n \"{})\\\".format( self.alias, \\\", \\\".join(by) ), \\\"STDDEV({}) OVER (PARTITION BY {})\\\".format(\",\n \"Draws the donut chart of the vColumn based on an\",\n \"{} IS NOT NULL GROUP BY {} ORDER BY {}\\\".format(\",\n \": Computes statistics of a numerical column for each vColumn\",\n \"\\\"SELECT PERCENTILE_CONT({}) WITHIN GROUP (ORDER BY {}) OVER (), PERCENTILE_CONT(1\",\n \"LIMIT 20\\\".format( self.alias, dtype, self.alias, self.parent.__genSQL__(), self.alias ) executeSQL(query, title=\\\"Testing\",\n \"See Also -------- vDataFrame[].fill_outliers : Fills the vColumn outliers using\",\n \"NULL values will not be considered during the computation. n:\",\n \"\\\"max_depth\\\": 8, \\\"nbins\\\": 100}) model.set_params(RFmodel_params) parameters = model.get_params() try: model.fit(tmp_view_name,\",\n \"NameError( f\\\"A vColumn has already the alias of one of\",\n \"str): \\\"\\\"\\\" --------------------------------------------------------------------------- Verifies if the regular expression is in\",\n \"self.parent.shape()[0] ) except: pass self.parent.__add_to_history__( \\\"[Discretize]: The vColumn {} was\",\n \"\\\"categorical\\\") ): query = \\\"\\\"\\\"(SELECT {0} || '', COUNT(*) FROM\",\n \"self.isdate(): min_date = self.min() table = \\\"(SELECT DATEDIFF('second', '{}'::timestamp, {})\",\n \": trigonometric inverse sine atan : trigonometric inverse tangent cbrt\",\n \"kth most occurent element (ex: top1 for the mode) topk_percent\",\n \"{} WHERE {} IS NOT NULL ORDER BY {} DESC\",\n \") query = \\\"SELECT {} FROM (SELECT {}, ROW_NUMBER() OVER\",\n \"int Number of digits to keep after the comma. Returns\",\n \"kwargs[\\\"legend\\\"] = True if not (\\\"figsize\\\" in kwargs): kwargs[\\\"figsize\\\"] =\",\n \"with 20 trees and a maximum depth of 10. response:\",\n \"# ---# def density( self, by: str = \\\"\\\", bandwidth:\",\n \"its abstractions. Parameters ---------- alias: str vColumn alias. transformations: list,\",\n \"converted to {}.\\\".format( self.alias, dtype ) ) return self.parent except\",\n \"True if the vColumn is numerical. \\\"\\\"\\\" return self.ctype().lower() in\",\n \"True, draw a Step Plot. ax: Matplotlib axes object, optional\",\n \"distributed on an \\\"AS IS\\\" BASIS, # WITHOUT WARRANTIES OR\",\n \"during the computation. cat_stats : Computes statistics of a numerical\",\n \"timestamp...) or numerical. by: str, optional vColumn to use to\",\n \"like: even: CASE ... WHEN vColumn = argv[2 * i]\",\n \"---------- n: int Number of digits to keep after the\",\n \"WHEN \\\" + \\\" WHEN \\\".join(conditions) + \\\" END\\\" self.apply(func=expr)\",\n \"self.ctype(), self.category())] self.transformations += [(new_column, ctype, category)] try: sauv =\",\n \"percentile = 0.25) AS Q1, APPROXIMATE_PERCENTILE({} USING PARAMETERS percentile =\",\n \"to compute the optimal h.\\\", method=\\\"fetchrow\\\", ) count, vColumn_min, vColumn_025,\",\n \"than quantile(1-alpha) will be filled. Returns ------- vDataFrame self.parent See\",\n \"\\\"[Apply]: The vColumn '{}' was transformed with the func 'x\",\n \"check_types([(\\\"x\\\", x, [int, float], (\\\"approx\\\", approx, [bool]))]) prefix = \\\"approx_\\\"\",\n \"add(self, x: float): \\\"\\\"\\\" --------------------------------------------------------------------------- Adds the input element to\",\n \"[ \\\"(SELECT READ_TREE(USING PARAMETERS model_name = '{}', tree_id = {},\",\n \"---# def cut( self, breaks: list, labels: list = [],\",\n \"binary to use iv_woe.\\\".format(y) ) response_cat = self.parent[y].distinct() response_cat.sort() assert\",\n \"were \\\" if total > 1 else \\\" was \\\"\",\n \"conj, ) ) else: if verticapy.options[\\\"print_info\\\"]: print(\\\"Nothing was filled.\\\") self.transformations\",\n \"See Also -------- vDataFrame.apply : Applies functions to the input\",\n \"BETWEEN {} AND {})\\\".format(self.alias, p_alpha, p_1_alpha) ) return self.parent #\",\n \"float]), (\\\"pie_type\\\", pie_type, [\\\"auto\\\", \\\"donut\\\", \\\"rose\\\"]), ] ) donut =\",\n \"\\\"''\\\"), value.replace(\\\"'\\\", \\\"''\\\") ) ) # ---# def str_slice(self, start:\",\n \"index_start += self.parent.shape()[0] if isinstance(index_stop, int): if index_stop < 0:\",\n \"self.alias ), method=\\\"fetchall\\\", ) values = { \\\"index\\\": [item[0] for\",\n \"self.aggregate(func=[\\\"unique\\\"]).values[self.alias][0] # ---# def pie( self, method: str = \\\"density\\\",\",\n \"'median'. Parameters ---------- approx: bool, optional If set to True,\",\n \"\\\\ \\\\_____\\\\ \\\\ \\\\_____\\\\ \\\\ \\\\_\\\\ \\\\ \\\\_\\\\ \\\\ \\\\_\\\\\\\\\\\"\\\\_\\\\\",\n \"the vColumn using the input list. Parameters ---------- breaks: list\",\n \"total) except Exception as e: self.transformations = [elem for elem\",\n \"{} largest elements.\\\".format(self.alias, n) return to_tablesample(query, title=title) # ---# def\",\n \"self.aggregate(func=[\\\"std\\\", \\\"avg\\\"]).transpose().values self.parent.filter( \\\"ABS({} - {}) / {} < {}\\\".format(\",\n \"bound itself. Parameters ---------- lower: float, optional Lower bound. upper:\",\n \"cmin, \\\"NULLIFZERO\\\" if (nullifzero) else \\\"\\\", cmax, cmin, ), \\\"float\\\",\",\n \"of seconds, otherwise it will represent a number. Returns -------\",\n \"quantile (ex: 50% for the median) prod : product range\",\n \"the above. The idea is simple: instead of moving #\",\n \"] if method != \\\"cat_stats\\\": values = { \\\"index\\\": [\\\"name\\\",\",\n \"\\\"pad\\\", \\\"bfill\\\", \\\"backfill\\\"): assert order_by, ParameterError( \\\"If the method is\",\n \"use_numbers_as_suffix: bool, optional Uses numbers as suffix instead of the\",\n \"func 'x -> {}'.\\\".format( copy_name.replace('\\\"', \\\"\\\"), func.replace(\\\"{}\\\", \\\"x\\\"), ) )\",\n \"vColumn using a user-defined encoding. vDataFrame[].discretize : Discretizes the vColumn.\",\n \"(x - avg) / std robust_zscore : Normalization using the\",\n \"method == \\\"minmax\\\": if n == 0: nullifzero = 0\",\n \"vColumn_min, vColumn_025, vColumn_075, vColumn_max = result sturges = max( float(vColumn_max\",\n \"(c) Copyright [2018-2022] Micro Focus or one of its affiliates.\",\n \"to the Matplotlib functions. Returns ------- ax Matplotlib axes object\",\n \"item in result], } return tablesample(values) # ---# def value_counts(self,\",\n \"---# def numh(self, method: str = \\\"auto\\\"): \\\"\\\"\\\" --------------------------------------------------------------------------- Computes\",\n \": Computes the vDataFrame input aggregations. \\\"\\\"\\\" check_types([(\\\"approx\\\", approx, [bool])])\",\n \"# ---# def std(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using\",\n \"pow : number raised to the power of another number\",\n \"a response. \\\"\\\"\\\" import verticapy.stats as st return self.apply(func=st.decode(str_sql(\\\"{}\\\"), *argv))\",\n \"check_types([(\\\"x\\\", x, [int, float])]) assert x != 0, ValueError(\\\"Division by\",\n \"\\\"cut only works on numerical / date-like vColumns.\\\" ) assert\",\n \"have a numerical value\\\" ) lower_when = ( \\\"WHEN {}\",\n \"meaning global outlier). \\\"\\\"\\\" check_types( [ (\\\"alpha\\\", alpha, [int, float]),\",\n \"use_threshold: bool = True, alpha: float = 0.05 ): \\\"\\\"\\\"\",\n \"n smallest elements in the vColumn. Parameters ---------- n: int,\",\n \"vColumn type iqr : interquartile range kurtosis : kurtosis jb\",\n \"vColumn( name, parent=self.parent, transformations=transformations, catalog={ \\\"min\\\": 0, \\\"max\\\": 1, \\\"count\\\":\",\n \"x)) # ---# def drop(self, add_history: bool = True): \\\"\\\"\\\"\",\n \"vDataFrame self.parent See Also -------- vDataFrame.drop: Drops the input vColumns\",\n \"\\\"freedman_diaconis\\\", \\\"fd\\\", \\\"auto\\\"])] ) method = method.lower() if method ==\",\n \"use to partition the data. h: float, optional Interval width\",\n \"\\\"median\\\") else \\\"AVG\\\" if by == []: if fun ==\",\n \"{}({} - {})\\\".format( self.alias, cmin, \\\"NULLIFZERO\\\" if (nullifzero) else \\\"\\\",\",\n \"= 0, max_cardinality: int = 8, cat_priority: list = [],\",\n \"value. vDataFrame[].str_slice : Slices the vColumn. \\\"\\\"\\\" check_types([(\\\"pat\\\", pat, [str])])\",\n \"\\\"bool\\\" else: category, ctype = self.category(), self.ctype() copy_trans = [elem\",\n \"-= len(self.transformations) for k in range(max_floor): self.transformations += [(\\\"{}\\\", self.ctype(),\",\n \"are using. Returns ------- tablesample An object containing the result.\",\n \"isinstance(cat_priority, str) or not (isinstance(cat_priority, Iterable)): cat_priority = [cat_priority] check_types(\",\n \"result = [self.min()] + result + [self.max()] elif method ==\",\n \"statistics. \\\"\\\"\\\" return self.describe(method=\\\"categorical\\\", max_cardinality=k) # ---# def var(self): \\\"\\\"\\\"\",\n \"nbins. If empty, an optimized number of nbins will be\",\n \"method to 'numerical' if the vColumn is numerical , 'categorical'\",\n \"method=\\\"model\\\") raise drop(tmp_view_name, method=\\\"view\\\") drop(tmp_model_name, method=\\\"model\\\") result = [self.min()] +\",\n \"'x' represents the second argument. Returns ------- vDataFrame self.parent See\",\n \"partition the data. method: str, optional The method to use\",\n \"self.parent[y].distinct() response_cat.sort() assert response_cat == [0, 1], TypeError( \\\"vColumn {}\",\n \"self.alias, self.alias, self.alias, self.alias, self.alias, table ) result = executeSQL(\",\n \"x)) # ---# def sum(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn\",\n \"Parameters ---------- to_replace: str Regular expression to replace. value: str,\",\n \"category. h: float, optional The interval size to convert to\",\n \"prefix_sep.replace('\\\"', \\\"_\\\") ) n = 1 if drop_first else 0\",\n \"the computation. n: int, optional Integer corresponding to the offset.\",\n \"in elem: if \\\"percent\\\" in elem: self.catalog[elem] = sauv[elem] elif\",\n \"names will be generated. include_lowest: bool, optional If set to\",\n \"\\\"SELECT COUNT({}) AS NAs, MIN({}) AS min, APPROXIMATE_PERCENTILE({} USING PARAMETERS\",\n \"elif method == \\\"minmax\\\": if n == 0: nullifzero =\",\n \"float]), (\\\"use_threshold\\\", use_threshold, [bool]), (\\\"threshold\\\", threshold, [int, float]), ] )\",\n \"type. Returns ------- str vColumn DB type. \\\"\\\"\\\" return self.transformations[-1][1].lower()\",\n \"elem in values: for i in range(len(values[elem])): if isinstance(values[elem][i], decimal.Decimal):\",\n \"/ (max - min) by: list, optional vColumns used in\",\n \"kernel. nbins: int, optional Maximum number of points to use\",\n \"/ **kwargs Any optional parameter to pass to the geopandas\",\n \"lower, [float, int]), (\\\"upper\\\", upper, [float, int])]) assert (lower !=\",\n \"0, ax=None, **style_kwds, ): \\\"\\\"\\\" --------------------------------------------------------------------------- Draws the histogram of\",\n \"= [self.alias] if of: self.parent.are_namecols_in(of) of = self.parent.format_colnames(of) from verticapy.plot\",\n \"OFFSET {} LIMIT 1\\\".format( self.alias, cast, self.parent.__genSQL__(), self.parent.__get_last_order_by__(), index, )\",\n \"1.\\\" ) index_stop = index.stop index_start = index.start if not\",\n \"# \\\\_______/ / / # ______ / / # \\\\\",\n \"/ # \\\\/ / / # / / # /\",\n \"dict = {}, response: str = \\\"\\\", return_enum_trans: bool =\",\n \"vDataFrame. Dropping a vColumn means simply not selecting it in\",\n \"(tuple, list)): xlim_tmp = [xlim] else: xlim_tmp = [] model\",\n \"\\\"cat_stats\\\") and (numcol != \\\"\\\"): numcol = self.parent.format_colnames(numcol) assert self.parent[numcol].category()\",\n \"Returns ------- tablesample An object containing the result. For more\",\n \"\\\"\\\"\\\" return self.aggregate([\\\"avg\\\"]).values[self.alias][0] mean = avg # ---# def bar(\",\n \"start, step)) # ---# def sub(self, x: float): \\\"\\\"\\\" ---------------------------------------------------------------------------\",\n \"self.alias, self.parent.__genSQL__(), by[0] ) result = executeSQL( query, title=\\\"Computing the\",\n \"the Random Forest on a response column to find the\",\n \"else \\\"NULL\\\", elem[2] if elem[2] != None else \\\"NULL\\\", )\",\n \"bool, optional If set to True, draw a Step Plot.\",\n \"FROM {} WHERE {} IS NOT NULL LIMIT 0\\\".format( func.replace(\\\"{}\\\",\",\n \"dummies ({name}).\\\\n\\\" \\\"It can be the result of using previously\",\n \"the record is greater than the threshold, it will be\",\n \"\\\" \\\"or simply because of ambiguous columns naming.\\\\nBy changing one\",\n \"\\\"\\\"\\\" check_types([(\\\"pat\\\", pat, [str])]) return self.apply( func=\\\"REGEXP_SUBSTR({}, '{}')\\\".format(\\\"{}\\\", pat.replace(\\\"'\\\", \\\"''\\\"))\",\n \"h: float, optional Interval width of the bar. If empty,\",\n \"of elements. same_width : Computes regular width bins. smart :\",\n \"assert nb != 0, Exception( \\\"Not enough values to compute\",\n \"return self.aggregate([\\\"stddev\\\"]).values[self.alias][0] stddev = std # ---# def store_usage(self): \\\"\\\"\\\"\",\n \"{} LIMIT 1\\\".format( alpha, self.alias, alpha, self.alias, self.parent.__genSQL__() ) p_alpha,\",\n \"input vColumns. vDataFrame.applymap : Applies a function to all the\",\n \"Parameters ---------- field: str The field to extract. It must\",\n \"'mad' (median absolute deviation). Returns ------- float mad See Also\",\n \"donut chart of the vColumn based on an aggregation. \\\"\\\"\\\"\",\n \"( \\\" WHERE {} IS NULL\\\".format(self.alias) if (category in (\\\"None\\\",\",\n \"= max(math.floor(best_h), 1) return best_h # ---# def nunique(self, approx:\",\n \"transformations=[item for item in self.transformations], catalog=self.catalog, ) setattr(self.parent, name, new_vColumn)\",\n \"using TS methods. Returns ------- vDataFrame self.parent See Also --------\",\n \"new_name = new_name.replace('\\\"', \\\"\\\") assert not (self.parent.is_colname_in(new_name)), NameError( f\\\"A vColumn\",\n \"def fill_outliers( self, method: str = \\\"winsorize\\\", threshold: float =\",\n \"== 1: lp, rp = \\\"(\\\", \\\")\\\" else: lp, rp\",\n \"(\\\"end_date\\\", end_date, [str, datetime.datetime, datetime.date]), (\\\"area\\\", area, [bool]), (\\\"step\\\", step,\",\n \"), title=\\\"Computing the different categories to normalize.\\\", method=\\\"fetchall\\\", ) for\",\n \"float = 0, nbins: int = -1, k: int =\",\n \"is returned. By setting this parameter to False, the function's\",\n \"vDataFrame history. Returns ------- vDataFrame self.parent See Also -------- vDataFrame.drop:\",\n \"not empty, a copy will be created using the input\",\n \"== \\\"AVG\\\": val = self.avg() elif fun == \\\"MEDIAN\\\": val\",\n \"( ((distinct_count < max_cardinality + 1) and (method != \\\"numerical\\\"))\",\n \"software # distributed under the License is distributed on an\",\n \") return self.parent # ---# def aggregate(self, func: list): \\\"\\\"\\\"\",\n \"at the final transformation. Returns ------- vDataFrame self.parent See Also\",\n \"order_by_ts ) if method in (\\\"mean\\\", \\\"median\\\") or isinstance(val, float):\",\n \"\\\"\\\"): \\\"\\\"\\\" --------------------------------------------------------------------------- Replaces the regular expression matches in each\",\n \"elem in all_partition: if len(self.parent[elem].transformations) > max_floor: max_floor = len(self.parent[elem].transformations)\",\n \"'Others', SUM(count) FROM (SELECT COUNT(*) AS count\\\" \\\" FROM vdf_table\",\n \"method == \\\"robust_zscore\\\": if n > 0: warning_message = \\\"The\",\n \"rename(self, new_name: str): \\\"\\\"\\\" --------------------------------------------------------------------------- Renames the vColumn by dropping\",\n \"limit <= 0: limit = 0 limit = \\\" LIMIT\",\n \"NOT NULL \\\".format(self.alias) if (dropna) else \\\" \\\" result =\",\n \"vDataFrame[].apply : Applies a function to the vColumn. \\\"\\\"\\\" check_types(\",\n \"int/float, optional If the function has two arguments (example, power\",\n \"quantile(alpha) or greater than quantile(1-alpha) will be filled. Returns -------\",\n \"n >= 1, ParameterError(\\\"Parameter 'n' must be greater or equal\",\n \"/ / / # |____/ / / # _____________ /\",\n \"assert self.parent[response].isnum(), TypeError( \\\"The response column must be numerical to\",\n \"{}\\\\n{} feature{}created: {}\\\".format( self.alias, len(all_new_features), conj, \\\", \\\".join(all_new_features) ) +\",\n \"------- vDataFrame self.parent See Also -------- vDataFrame[].str_count : Computes the\",\n \") method = method.lower() assert (method != \\\"cat_stats\\\") or (numcol),\",\n \"cutomized aggregation (ex: AVG(column1) + 5). ax: Matplotlib axes object,\",\n \"'[{};{}]' \\\".format( \\\"{}\\\", result[i - 1], result[i], result[i - 1],\",\n \"self.parent.__genSQL__(), \\\" UNION ALL \\\".join(query) ) title = \\\"Describes the\",\n \"ALL (SELECT 'Others', SUM(count) FROM (SELECT COUNT(*) AS count\\\" \\\"\",\n \"query = \\\"SELECT {}{} FROM {}{} OFFSET {} LIMIT 1\\\".format(\",\n \"casting.\\\") self.transformations += [ ( \\\"{}::{}\\\".format(\\\"{}\\\", dtype), dtype, get_category_from_vertica_type(ctype=dtype), )\",\n \"/ {}) * {} || ';' || (FLOOR({} / {})\",\n \"+= [elem for elem in order_by] for elem in all_partition:\",\n \"skewness : skewness sum : sum std : standard deviation\",\n \"---# def head(self, limit: int = 5): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns\",\n \"int = 6, h: float = 0, pie_type: str =\",\n \"str = \\\"second\\\", start: bool = True): \\\"\\\"\\\" --------------------------------------------------------------------------- Slices\",\n \"considered as an outlier. use_threshold: bool, optional Uses the threshold\",\n \"[item[1] for item in query_result] index = [\\\"unique\\\", \\\"count\\\"] +\",\n \"[ ( \\\"({} - {}) / {}({} - {})\\\".format( \\\"{}\\\",\",\n \"= ( sys.getsizeof(self) + sys.getsizeof(self.alias) + sys.getsizeof(self.transformations) + sys.getsizeof(self.catalog) )\",\n \"2, ParameterError( \\\"Length of parameter 'breaks' must be greater or\",\n \"MIN({3}{4}) AS min, APPROXIMATE_PERCENTILE ({3}{4} USING PARAMETERS percentile = 0.1)\",\n \"# / # ____________ ______ # / __ `\\\\ /\",\n \"If the vDataFrame represents the entire relation, a vColumn can\",\n \"distribution. mean : Average of the vColumn 'of'. min :\",\n \"be binary to use iv_woe.\\\".format(y) ) response_cat = self.parent[y].distinct() response_cat.sort()\",\n \"def get_dummies( self, prefix: str = \\\"\\\", prefix_sep: str =\",\n \"ax=None, **style_kwds, ): \\\"\\\"\\\" --------------------------------------------------------------------------- Draws the vColumn Density Plot.\",\n \"greater or equals to 2 in case of discretization using\",\n \"pie chart of the vColumn based on an aggregation. Parameters\",\n \"from verticapy.plot import ts_plot return ts_plot( self, ts, by, start_date,\",\n \"in (\\\"float\\\", \\\"int\\\") # ---# def iv_woe(self, y: str, nbins:\",\n \"vColumn records. vDataFrame[].extract : Extracts the regular expression in each\",\n \"deviation approx_unique : approximative cardinality count : number of non-missing\",\n \"{} AS {}, {} AS ord, {}::int AS {} FROM\",\n \"(trans, \\\"varchar\\\", \\\"text\\\") if return_enum_trans: return trans else: self.transformations +=\",\n \"occurent element (ex: top1 for the mode) topk_percent : kth\",\n \"count\\\" \\\" FROM vdf_table WHERE {0} IS NOT NULL GROUP\",\n \"Uses method 'same_width' for numerical vColumns, cast the other types\",\n \"[ ( \\\"method\\\", method, [ \\\"auto\\\", \\\"mode\\\", \\\"0ifnull\\\", \\\"mean\\\", \\\"avg\\\",\",\n \"total < int(float(count / int(nbins))) * int(nbins): nth_elems += [str(total)]\",\n \"'cat_stats'. Returns ------- tablesample An object containing the result. For\",\n \"------- ax Matplotlib axes object See Also -------- vDataFrame[].bar :\",\n \"distributions as percents. Parameters ---------- k: int, optional Number of\",\n \") ): max_floor = max( len(self.parent[column].transformations), max_floor ) except: pass\",\n \"{}'.\\\".format( self.alias.replace('\\\"', \\\"\\\"), func.replace(\\\"{}\\\", \\\"x\\\"), ) ) return self.parent except\",\n \"THEN 0 ELSE ZEROIFNULL(LN(pt_non_events / NULLIFZERO(pt_events))) END AS woe, CASE\",\n \"or self.isdate(), ParameterError( \\\"numh is only available on type numeric|date\\\"\",\n \"expression matches in each of the vColumn record by an\",\n \"index, non_events, events, pt_non_events, pt_events, CASE WHEN non_events = 0\",\n \"deviation max : maximum mean : average median : median\",\n \"atan : trigonometric inverse tangent cbrt : cube root ceil\",\n \"describe( self, method: str = \\\"auto\\\", max_cardinality: int = 6,\",\n \"Computes the vDataFrame input aggregations. \\\"\\\"\\\" check_types( [ (\\\"method\\\", method,\",\n \"self.catalog[\\\"count\\\"] = int(sauv[\\\"count\\\"]) + total self.catalog[\\\"percent\\\"] = ( 100 *\",\n \"---------- x: float A float between 0 and 1 that\",\n \"self.isdate(): return self.apply(func=\\\"TIMESTAMPADD(SECOND, -({}), {})\\\".format(x, \\\"{}\\\")) else: return self.apply(func=\\\"{} -\",\n \"optimized number of bins will be computed. h: float, optional\",\n \"query += [lp + tmp_query + rp] query = \\\"WITH\",\n \"[ (\\\"by\\\", by, [str]), (\\\"kernel\\\", kernel, [\\\"gaussian\\\", \\\"logistic\\\", \\\"sigmoid\\\", \\\"silverman\\\"]),\",\n \"One-Hot Encoding. vDataFrame[].label_encode : Encodes the vColumn with Label Encoding.\",\n \"+ [item[0] for item in query_result] else: result = (\",\n \"({}) VERTICAPY_SUBTABLE WHERE split_value IS NOT NULL GROUP BY 1\",\n \"( sauv[\\\"max\\\"] - sauv[\\\"min\\\"] ) except: pass if method ==\",\n \"on an aggregation. \\\"\\\"\\\" check_types( [ (\\\"method\\\", method, [str]), (\\\"of\\\",\",\n \"[str]), (\\\"drop_first\\\", drop_first, [bool]), (\\\"use_numbers_as_suffix\\\", use_numbers_as_suffix, [bool]), ] ) distinct_elements\",\n \"0\\\".format( func.replace(\\\"{}\\\", self.alias), self.parent.__genSQL__(), self.alias, ), \\\"apply_test_feature\\\", ) except: ctype\",\n \"performance can drastically decrease. Returns ------- float quantile (or approximate\",\n \"the vColumn using a time series rule. Parameters ---------- length:\",\n \"\\\"ln\\\", \\\"log\\\", \\\"log10\\\", \\\"mod\\\", \\\"pow\\\", \\\"round\\\", \\\"sign\\\", \\\"sin\\\", \\\"sinh\\\", \\\"sqrt\\\",\",\n \"empty, an optimized number of nbins will be computed. h:\",\n \"[\\\"total\\\"] result.values[\\\"non_events\\\"] += [sum(result[\\\"non_events\\\"])] result.values[\\\"events\\\"] += [sum(result[\\\"events\\\"])] result.values[\\\"pt_non_events\\\"] += [\\\"\\\"]\",\n \"prefix, str(distinct_elements[k]).replace('\\\"', \\\"_\\\") ) ) name = ( name.replace(\\\" \\\",\",\n \"partition the data. bandwidth: float, optional The bandwidth of the\",\n \"if isinstance(pie_type, str): pie_type = pie_type.lower() check_types( [ (\\\"method\\\", method,\",\n \"if method == \\\"auto\\\": pre_comp = self.parent.__get_catalog_value__(self.alias, \\\"numh\\\") if pre_comp\",\n \"p_1_alpha) ) return self.parent # ---# def dropna(self): \\\"\\\"\\\" ---------------------------------------------------------------------------\",\n \"of, max_cardinality, nbins, h, ax=ax, **style_kwds) # ---# def iloc(self,\",\n \"return_enum_trans, [bool]), ] ) method = method.lower() if self.isnum() and\",\n \"by: list = [], order_by: list = [], ): \\\"\\\"\\\"\",\n \"to False, the function's performance can drastically decrease. Returns -------\",\n \"vDataFrame.drop: Drops the input vColumns from the vDataFrame. \\\"\\\"\\\" check_types([(\\\"add_history\\\",\",\n \"except: model.drop() raise # ---# def describe( self, method: str\",\n \"data. bandwidth: float, optional The bandwidth of the kernel. kernel:\",\n \"= \\\" WHERE {} IS NOT NULL\\\".format(self.alias) if (dropna) else\",\n \"------- float/str maximum See Also -------- vDataFrame.aggregate : Computes the\",\n \"self.drop(add_history=False) parent.__add_to_history__( \\\"[Rename]: The vColumn {} was renamed '{}'.\\\".format(old_name, new_name)\",\n \"being the vColumn cardinality). Returns ------- vDataFrame self.parent See Also\",\n \"itself. Parameters ---------- lower: float, optional Lower bound. upper: float,\",\n \"vColumn DB type. Returns ------- str vColumn DB type. \\\"\\\"\\\"\",\n \"See Also -------- vDataFrame[].describe : Computes the vColumn descriptive statistics.\",\n \"prefix = ( self.alias.replace('\\\"', \\\"\\\") + prefix_sep.replace('\\\"', \\\"_\\\") if not\",\n \"the search. See Also -------- vDataFrame.isin : Looks if some\",\n \"self.parent force_columns = [ column for column in self.parent._VERTICAPY_VARIABLES_[\\\"columns\\\"] ]\",\n \"\\\"{}\\\") self.apply(func=func) return self.parent # ---# def count(self): \\\"\\\"\\\" ---------------------------------------------------------------------------\",\n \"for item in result], } return tablesample(values) # ---# def\",\n \"in [\\\"ffill\\\", \\\"pad\\\", \\\"bfill\\\", \\\"backfill\\\"]: all_partition += [elem for elem\",\n \"(Constant Interpolation). ffill : Propagation of the first element (Constant\",\n \") category = get_category_from_vertica_type(ctype=ctype) all_cols, max_floor = self.parent.get_columns(), 0 for\",\n \"return \\\"({} - {}) / ({})\\\".format(self.alias, med, mad) else: final_transformation\",\n \"the time series. \\\"\\\"\\\" check_types( [ (\\\"ts\\\", ts, [str]), (\\\"by\\\",\",\n \"'kurtosis'. Returns ------- float kurtosis See Also -------- vDataFrame.aggregate :\",\n \"the parameter is empty or invalid. max_cardinality: int/tuple, optional Maximum\",\n \"= kwargs[\\\"column\\\"] else: check = False if check: self.parent.are_namecols_in(column) column\",\n \"( \\\"end_date\\\", end_date, [str, datetime.datetime, datetime.date, int, float], ), (\\\"plot_median\\\",\",\n \"# Licensed under the Apache License, Version 2.0 (the \\\"License\\\");\",\n \"return parent # ---# def drop_outliers( self, threshold: float =\",\n \"in copy_trans] raise QueryError(\\\"{}\\\\nAn Error happened during the filling.\\\".format(e)) if\",\n \"IS NOT NULL LIMIT 20\\\".format( self.alias, dtype, self.alias, self.parent.__genSQL__(), self.alias\",\n \"'' ELSE '{}' END)\\\".format( bin_spatial_to_str(self.category()), \\\", \\\".join( [ \\\"'{}'\\\".format(str(elem).replace(\\\"'\\\", \\\"''\\\"))\",\n \"min_date, self.alias, self.alias, self.parent.__genSQL__() ) query = \\\"SELECT COUNT({}) AS\",\n \"# ---# def category(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns the category of\",\n \"\\\"{}\\\", partition_by, order_by_ts ) if method in (\\\"mean\\\", \\\"median\\\") or\",\n \"): n = len(result) trans = \\\"(CASE \\\" for i\",\n \"'robust_zscore' is available only if the parameter 'by' is empty\\\\nIf\",\n \"customized expression. \\\"\\\"\\\" if isinstance(func, str_sql): func = str(func) check_types([(\\\"func\\\",\",\n \"vColumn using 'sem' (standard error of mean). Returns ------- float\",\n \") for idx, elem in enumerate(result): result[idx][0] = ( \\\"NULL\\\"\",\n \"in range(max_floor): self.transformations += [(\\\"{}\\\", self.ctype(), self.category())] self.transformations += [\",\n \"+ prefix_sep.replace('\\\"', \\\"_\\\") if not (prefix) else prefix.replace('\\\"', \\\"_\\\") +\",\n \"equal to 0, an optimised interval will be computed. nbins:\",\n \"def range_plot( self, ts: str, q: tuple = (0.25, 0.75),\",\n \"some specific records are in the vDataFrame. \\\"\\\"\\\" if isinstance(val,\",\n \"parent, vDataFrame : Parent of the vColumn. transformations, str :\",\n \"bar. If empty, an optimized h will be computed. ax:\",\n \"p_1_alpha, ) mean_alpha, mean_1_alpha = [ item[0] for item in\",\n \"int number of non-Missing elements. See Also -------- vDataFrame.aggregate :\",\n \"\\\"regr_slope\\\": {}, \\\"regr_sxx\\\": {}, \\\"regr_sxy\\\": {}, \\\"regr_syy\\\": {}, } for\",\n \"vColumn. labels: list, optional Labels used to name the new\",\n \"memory usage. Returns ------- float vColumn memory usage (byte) See\",\n \"+= [\\\"\\\"] result.values[\\\"pt_events\\\"] += [\\\"\\\"] result.values[\\\"woe\\\"] += [\\\"\\\"] result.values[\\\"iv\\\"] +=\",\n \"return self elif method == \\\"minmax\\\": if n == 0:\",\n \"str, optional The method to use to discretize the vColumn.\",\n \"Adds a new vColumn labeled with 0 and 1 (1\",\n \"response_cat.sort() assert response_cat == [0, 1], TypeError( \\\"vColumn {} must\",\n \"max(sturges, fd) self.parent.__update_catalog__({\\\"index\\\": [\\\"numh\\\"], self.alias: [best_h]}) if self.category() == \\\"int\\\":\",\n \"tmp_view_name = gen_tmp_name(schema=schema, name=\\\"view\\\") tmp_model_name = gen_tmp_name(schema=schema, name=\\\"model\\\") assert nbins\",\n \"and (self.parent[by[0]].nunique() < 50): try: if fun == \\\"MEDIAN\\\": fun\",\n \"[elem[0] for elem in result] except: drop(tmp_view_name, method=\\\"view\\\") drop(tmp_model_name, method=\\\"model\\\")\",\n \"If set to True, the lowest element of the list\",\n \"avg # ---# def bar( self, method: str = \\\"density\\\",\",\n \"model = KernelDensity( name, bandwidth=bandwidth, kernel=kernel, nbins=nbins, xlim=xlim_tmp, store=False, )\",\n \"BY {} ORDER BY _verticapy_cnt_ DESC LIMIT {}) VERTICAPY_SUBTABLE ORDER\",\n \"vColumn to use to compute the aggregation. max_cardinality: int, optional\",\n \"\\\"\\\" if (method in (\\\"ffill\\\", \\\"pad\\\")) else \\\" DESC\\\" partition_by\",\n \"aggregations. \\\"\\\"\\\" return self.aggregate([\\\"avg\\\"]).values[self.alias][0] mean = avg # ---# def\",\n \") return self.parent except Exception as e: raise QueryError( \\\"{}\\\\nError\",\n \": Applies a function to the input vColumn. \\\"\\\"\\\" return\",\n \"Function to use to transform the vColumn. abs : absolute\",\n \"> 0: column = args[0] elif \\\"column\\\" in kwargs: column\",\n \"cmin, ) else: final_transformation = [ ( \\\"({} - {})\",\n \"query_result] index = [\\\"unique\\\", \\\"count\\\"] + [item[0] for item in\",\n \"check_types( [ (\\\"prefix\\\", prefix, [str]), (\\\"prefix_sep\\\", prefix_sep, [str]), (\\\"drop_first\\\", drop_first,\",\n \"input expression. \\\"\\\"\\\" self.parent.filter(\\\"{} IS NOT NULL\\\".format(self.alias)) return self.parent #\",\n \"will be computed. pie_type: str, optional The type of pie\",\n \"return hist(self, method, of, max_cardinality, nbins, h, ax=ax, **style_kwds) #\",\n \"] query = \\\"SELECT split_value FROM (SELECT split_value, MAX(weighted_information_gain) FROM\",\n \"use_threshold: result = self.aggregate(func=[\\\"std\\\", \\\"avg\\\"]).transpose().values p_alpha, p_1_alpha = ( -threshold\",\n \"the vColumn. \\\"\\\"\\\" check_types( [ (\\\"length\\\", length, [int, float]), (\\\"unit\\\",\",\n \"offers beautiful graphical options. # # VerticaPy aims to do\",\n \"use to transform the vColumn. abs : absolute value acos\",\n \"input aggregations. \\\"\\\"\\\" return self.aggregate([\\\"stddev\\\"]).values[self.alias][0] stddev = std # ---#\",\n \"is simple: instead of moving # data around for processing,\",\n \"title=\\\"Computing the average of the {}'s lower and upper outliers.\\\".format(\",\n \"self.alias, \\\", \\\".join(by) ), ) else: cmax, cmin = (\",\n \"/ / # ______ / / # \\\\ / /\",\n \"expr, [str]), (\\\"by\\\", by, [list]), (\\\"order_by\\\", order_by, [list]), ] )\",\n \"float(vColumn_max - vColumn_min) / int(math.floor(math.log(count, 2) + 2)), 1e-99, )\",\n \"if the vColumn is numerical or of type date like.\",\n \"How the intervals should be closed. If set to True,\",\n \"int = 1): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns the nth most occurent\",\n \"or not (is_numeric) or (method == \\\"categorical\\\") ): query =\",\n \"query += ( \\\"UNION ALL (SELECT 'Others', SUM(count) FROM (SELECT\",\n \"10. response: str, optional Response vColumn when method is set\",\n \"\\\", {})\\\".format(len(distinct_elements)) self.transformations += [(expr, \\\"int\\\", \\\"int\\\")] self.parent.__update_catalog__(erase=True, columns=[self.alias]) self.catalog[\\\"count\\\"]\",\n \"str) or not (isinstance(val, Iterable)): val = [val] val +=\",\n \"method=\\\"view\\\") drop(tmp_model_name, method=\\\"model\\\") raise drop(tmp_view_name, method=\\\"view\\\") drop(tmp_model_name, method=\\\"model\\\") result =\",\n \"YEAR Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].slice :\",\n \"x ORDER BY ord\\\".format( self.alias, query, ) title = \\\"Computing\",\n \"catalog: dict, optional Catalog where each key corresponds to an\",\n \"using the input functions. Parameters ---------- func: list List of\",\n \"the 3rd. area: bool, optional If set to True, draw\",\n \"] ) distinct_elements = self.distinct() if distinct_elements not in ([0,\",\n \"in each of the vColumn records by an input value.\",\n \"elif method == \\\"zscore\\\": self.catalog[elem] = (sauv[elem] - sauv[\\\"mean\\\"]) /\",\n \"elif n == 1: try: result = executeSQL( \\\"SELECT {},\",\n \"of elements to display. offset: int, optional Number of elements\",\n \"{}))\\\".format( \\\"{}\\\", \\\"{}\\\", partition_by, order_by_ts ) if method in (\\\"mean\\\",\",\n \"( \\\"AVG({}) OVER (PARTITION BY {})\\\".format( self.alias, \\\", \\\".join(by) ),\",\n \"the vColumn. \\\"\\\"\\\" return self.iloc(limit=limit, offset=-1) # ---# def topk(self,\",\n \"vColumn to the vDataFrame by using an advanced analytical function\",\n \"\\\"\\\" ) order_by_ts = \\\", \\\".join([quote_ident(column) + desc for column\",\n \"------- vDataFrame self.parent See Also -------- vDataFrame[].dropna : Drops the\",\n \"sem : standard error of the mean skewness : skewness\",\n \"to 2 in case of discretization using the method 'same_freq'\\\"\",\n \"will also increase the time of the learning and scoring\",\n \"vDataFrame.aggregate : Computes the vDataFrame input aggregations. \\\"\\\"\\\" check_types( [\",\n \"response) query = [ \\\"(SELECT READ_TREE(USING PARAMETERS model_name = '{}',\",\n \"return self.aggregate(func=[\\\"approx_unique\\\"]).values[self.alias][0] else: return self.aggregate(func=[\\\"unique\\\"]).values[self.alias][0] # ---# def pie( self,\",\n \"the power of another number round : rounds a value\",\n \"vColumn by keeping only the input number of digits after\",\n \"will return the mode of the vColumn. Returns ------- str/float/int\",\n \"of using previously the method on the vColumn \\\" \\\"or\",\n \"using the following mapping:{}\\\".format( self.alias, text_info ) ) return self.parent\",\n \"max FROM vdf_table\\\"\\\"\\\".format( category, self.alias, self.parent.shape()[0], numcol, cast, ) tmp_query\",\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,\",\n \"like). The vColumn will be transformed. Parameters ---------- field: str\",\n \"(\\\"legend\\\" in kwargs): kwargs[\\\"legend\\\"] = True if not (\\\"figsize\\\" in\",\n \"number. Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].apply :\",\n \"SECOND / TIME ZONE / TIMEZONE_HOUR / TIMEZONE_MINUTE / WEEK\",\n \"iv_woe(self, y: str, nbins: int = 10): \\\"\\\"\\\" --------------------------------------------------------------------------- Computes\",\n \"self.alias ) values = to_tablesample(query, title=title).values elif ( ((distinct_count <\",\n \"> max_floor: max_floor = len(self.parent[elem].transformations) max_floor -= len(self.transformations) for k\",\n \"\\\\/_____/ \\\\/_/ \\\\/_/ \\\\/_/ \\\\/_/ # # # ---# class\",\n \"\\\\ \\\\ \\\\ \\\\____ \\\\ \\\\ \\\\_\\\\ \\\\ \\\\ \\\\\",\n \"date / int / float / text / binary /\",\n \"or h <= 0: if nbins <= 0: h =\",\n \"avg, stddev = ( \\\"AVG({}) OVER (PARTITION BY {})\\\".format( self.alias,\",\n \"float aad See Also -------- vDataFrame.aggregate : Computes the vDataFrame\",\n \"\\\"''\\\")) for elem in distinct ] ), bin_spatial_to_str(self.category()), new_category.replace(\\\"'\\\", \\\"''\\\"),\",\n \") else: new_column = \\\"COALESCE({}, {}({}) OVER (PARTITION BY {}))\\\".format(\",\n \"( self.parent.describe( method=\\\"numerical\\\", columns=[self.alias], unique=False ) .transpose() .values[self.alias] ) result\",\n \"result = executeSQL( query, title=\\\"Different aggregations to compute the optimal\",\n \"ASC LIMIT {}\\\".format( self.parent.__genSQL__(), self.alias, self.alias, n ) title =\",\n \"plot_median, [bool]), ] ) self.parent.are_namecols_in(ts) ts = self.parent.format_colnames(ts) from verticapy.plot\",\n \"return store_usage # ---# def str_contains(self, pat: str): \\\"\\\"\\\" ---------------------------------------------------------------------------\",\n \"self.aggregate(func=[\\\"std\\\", \\\"avg\\\"]).transpose().values p_alpha, p_1_alpha = ( -threshold * result[\\\"std\\\"][0] +\",\n \"cmin = ( \\\"MAX({}) OVER (PARTITION BY {})\\\".format( self.alias, \\\",\",\n \"the alias {name}.\\\\nBy changing the parameter 'name', you'll be able\",\n \"in self.transformations] total = self.count() if method not in [\\\"mode\\\",\",\n \"Warning) return self.parent if isinstance(val, str): val = val.replace(\\\"'\\\", \\\"''\\\")\",\n \"custom_lines = [] columns = self.parent[by].distinct() for idx, column in\",\n \"self.parent.quantile([alpha, 1 - alpha], [self.alias]) .transpose() .values[self.alias] ) self.parent.filter( \\\"({}\",\n \"None, ax=None, **style_kwds, ): \\\"\\\"\\\" --------------------------------------------------------------------------- Draws the vColumn Density\",\n \"== None) else \\\"'{}'\\\".format(str(elem[0]).replace(\\\"'\\\", \\\"''\\\")) ) result[idx][1] = \\\"NULL\\\" if\",\n \"of the {}'s lower and upper outliers.\\\".format( self.alias ), method=\\\"fetchall\\\",\",\n \"distinct categories of {}.\\\".format(self.alias), method=\\\"fetchall\\\", ) return [item for sublist\",\n \"\\\"(SELECT DATEDIFF('second', '{}'::timestamp, {}) AS {} FROM {}) VERTICAPY_OPTIMAL_H_TABLE\\\".format( min_date,\",\n \"!\\\".format( self.alias ) warnings.warn(warning_message, Warning) return self elif method ==\",\n \"empty, a copy will be created using the input Name.\",\n \"\\\"(CASE \\\" for i in range(1, n): trans += \\\"WHEN\",\n \"abs(self.count() - total) except Exception as e: self.transformations = [elem\",\n \"(delimited by an offset and a limit). Parameters ---------- limit:\",\n \"= ( \\\"label_encode is only available for categorical variables.\\\" )\",\n \"in by: if len(self.parent[elem].transformations) > max_floor: max_floor = len(self.parent[elem].transformations) max_floor\",\n \"self.parent.__genSQL__(), self.alias, ), \\\"apply_test_feature\\\", ) category = get_category_from_vertica_type(ctype=ctype) all_cols, max_floor\",\n \"if (method == \\\"median\\\") else \\\"AVG\\\" if by == []:\",\n \"== None: pass elif math.isnan(result[i][2]): result[i][2] = None avg =\",\n \"+ result + [self.max()] elif method == \\\"topk\\\": assert k\",\n \"True, the information will be stored in the vDataFrame history.\",\n \"if self.isbool(): warning_message = \\\"Normalize doesn't work on booleans\\\".format(self.alias) warnings.warn(warning_message,\",\n \"(\\\"by\\\", by, [str]), (\\\"method\\\", method, [str]), (\\\"of\\\", of, [str]), (\\\"max_cardinality\\\",\",\n \"+ sys.getsizeof(self.transformations) + sys.getsizeof(self.catalog) ) for elem in self.catalog: total\",\n \"1], TypeError( \\\"vColumn {} must be binary to use iv_woe.\\\".format(y)\",\n \"datetime.datetime, datetime.date] = \\\"\\\", area: bool = False, step: bool\",\n \"apply(self, func: str, copy_name: str = \\\"\\\"): \\\"\\\"\\\" --------------------------------------------------------------------------- Applies\",\n \"the Gaussian distribution to define the outliers. After normalizing the\",\n \"\\\"{}\\\", avg, \\\"NULLIFZERO\\\" if (nullifzero) else \\\"\\\", stddev ), \\\"float\\\",\",\n \"(\\\"unit\\\", unit, [str]), (\\\"start\\\", start, [bool]), ] ) start_or_end =\",\n \"outlier). \\\"\\\"\\\" if isinstance(method, str): method = method.lower() check_types( [\",\n \"limitations under the License. # # |_ |~) _ _|\",\n \"if total > 0: try: if \\\"count\\\" in sauv: self.catalog[\\\"count\\\"]\",\n \"BY {})\\\".format( self.alias, \\\", \\\".join(by) ), \\\"MIN({}) OVER (PARTITION BY\",\n \"it. This parameter is very useful for testing to be\",\n \"func: str, Function in pure SQL used to transform the\",\n \"(method == \\\"categorical\\\"): result = self.aggregate([\\\"count\\\", \\\"min\\\", \\\"max\\\"]) index =\",\n \"ZScores. threshold: float, optional Uses the Gaussian distribution to define\",\n \"the vColumn with the One-Hot Encoding algorithm. Parameters ---------- prefix:\",\n \"vColumn. \\\"\\\"\\\" check_types([(\\\"pat\\\", pat, [str])]) return self.apply( func=\\\"REGEXP_COUNT({}, '{}') >\",\n \"1] (n being the vColumn cardinality). Returns ------- vDataFrame self.parent\",\n \"---------- pat: str Regular expression. Returns ------- vDataFrame self.parent See\",\n \"value: str, optional New value. Returns ------- vDataFrame self.parent See\",\n \"\\\\-./\\\\ \\\\ \\\\ \\\\ \\\\-. \\\\ # \\\\ \\\\__| \\\\\",\n \"self.parent # ---# def distinct(self, **kwargs): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns the\",\n \"the n smallest elements in the vColumn. Parameters ---------- n:\",\n \"AS Q1, APPROXIMATE_PERCENTILE({} USING PARAMETERS percentile = 0.75) AS Q3,\",\n \"query = \\\"SELECT {}, MIN(ord) AS ord, SUM(1 - {})\",\n \"AS woe, CASE WHEN non_events = 0 OR events =\",\n \"self, by: str = \\\"\\\", h: float = 0, max_cardinality:\",\n \"OVER ()) AS pt_non_events, events / NULLIFZERO(SUM(events) OVER ()) AS\",\n \"\\\"avg\\\", \\\"median\\\"): fun = \\\"MEDIAN\\\" if (method == \\\"median\\\") else\",\n \"'sum'. Returns ------- float sum See Also -------- vDataFrame.aggregate :\",\n \"= kurtosis # ---# def label_encode(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Encodes the\",\n \"the descriptive statistics of {}.\\\".format(self.alias), method=\\\"fetchall\\\", ) result = [distinct_count,\",\n \"vColumn is missing. Returns ------- vDataFrame self.parent See Also --------\",\n \"= \\\"float\\\", \\\"float\\\" elif method == \\\"0ifnull\\\": category, ctype =\",\n \"to varchar. same_freq : Computes bins with the same number\",\n \"(\\\"h\\\", h, [int, float]), ] ) if of: self.parent.are_namecols_in(of) of\",\n \"self.parent.__add_to_history__( \\\"[Add Copy]: A copy of the vColumn {} named\",\n \"series. \\\"\\\"\\\" check_types( [ (\\\"ts\\\", ts, [str]), (\\\"by\\\", by, [str]),\",\n \"- {}) / {}({})\\\".format( \\\"{}\\\", avg, \\\"NULLIFZERO\\\" if (nullifzero) else\",\n \"normalized with the method '{}'.\\\".format( self.alias, method ) ) else:\",\n \"list List of the different records. For example, to check\",\n \"> 0 # ---# def __repr__(self): return self.head(limit=verticapy.options[\\\"max_rows\\\"]).__repr__() # ---#\",\n \"return self.aggregate([\\\"kurtosis\\\"]).values[self.alias][0] kurt = kurtosis # ---# def label_encode(self): \\\"\\\"\\\"\",\n \"if the method is 'cat_stats'\\\" ) distinct_count, is_numeric, is_date =\",\n \"values. \\\"\\\"\\\" if isinstance(by, str): by = [by] if isinstance(order_by,\",\n \"to train a Random Forest with 20 trees and a\",\n \"It tells the predictive power of an independent variable in\",\n \"the partition. return_trans: bool, optimal If set to True, the\",\n \"using a Z-Score - The Standard Deviation is null !\\\".format(\",\n \"Dropping a vColumn means simply not selecting it in the\",\n \"\\\"WITH vdf_table AS (SELECT * FROM {}) (SELECT AVG({}) FROM\",\n \"Returns ------- float kurtosis See Also -------- vDataFrame.aggregate : Computes\",\n \"self.parent.shape()[0] ) except: pass total = int(total) conj = \\\"s\",\n \"max_floor -= len(self.transformations) if copy_name: self.add_copy(name=copy_name) for k in range(max_floor):\",\n \"to True, draw an Area Plot. step: bool, optional If\",\n \"[float, int])]) assert (lower != None) or (upper != None),\",\n \") except: pass self.parent.__add_to_history__( \\\"[Discretize]: The vColumn {} was discretized.\\\".format(self.alias)\",\n \"e: raise ConversionError( \\\"{}\\\\nThe vColumn {} can not be converted\",\n \"not (self.parent.is_colname_in(name)), NameError( f\\\"A vColumn has already the alias of\",\n \"round : rounds a value to a specified number of\",\n \"--------------------------------------------------------------------------- Discretizes the vColumn using the input list. Parameters ----------\",\n \"try: model.fit(tmp_view_name, [self.alias], response) query = [ \\\"(SELECT READ_TREE(USING PARAMETERS\",\n \"One hot encoder was applied to the vColumn {}\\\\n{} feature{}created:\",\n \"n: int, optional Offset. Returns ------- tablesample An object containing\",\n \"ctype, category)] try: sauv = {} for elem in self.catalog:\",\n \"method not in [\\\"mode\\\", \\\"0ifnull\\\"]: max_floor = 0 all_partition =\",\n \"def head(self, limit: int = 5): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns the\",\n \"'nbins' must be greater or equals to 2 in case\",\n \"query=query, title=\\\"Computing the average of the {}'s lower and upper\",\n \"bool, optional If set to True, the approximate quantile is\",\n \"using 'var' (Variance). Returns ------- float var See Also --------\",\n \"/ # |____/ / / # _____________ / / #\",\n \"if (nullifzero) else \\\"\\\", stddev ), \\\"float\\\", \\\"float\\\", ) ]\",\n \"= [], self.distinct() if len(cat) == 1: lp, rp =\",\n \"VERTICAPY_SUBTABLE {}\\\".format( self.alias, self.alias, self.alias, self.parent.__genSQL__(), self.alias, where, ) result\",\n \") self.add_copy(new_name) parent = self.drop(add_history=False) parent.__add_to_history__( \\\"[Rename]: The vColumn {}\",\n \"= int(total) conj = \\\"s were \\\" if total >\",\n \"and scoring phases. xlim: tuple, optional Set the x limits\",\n \"upper=None): \\\"\\\"\\\" --------------------------------------------------------------------------- Clips the vColumn by transforming the values\",\n \"copy_name: self.add_copy(name=copy_name) for k in range(max_floor): self.parent[copy_name].transformations += [ (\\\"{}\\\",\",\n \"if not (prefix) else prefix.replace('\\\"', \\\"_\\\") + prefix_sep.replace('\\\"', \\\"_\\\") )\",\n \"# \\\\ / # \\\\/ # _ # \\\\ /\",\n \"new_vColumn) setattr(self.parent, name.replace('\\\"', \\\"\\\"), new_vColumn) self.parent._VERTICAPY_VARIABLES_[\\\"columns\\\"] += [name] all_new_features +=\",\n \"= int(float(count / int(nbins))) assert nb != 0, Exception( \\\"Not\",\n \"aggregations could work if it is part of the DB\",\n \"input vColumns. \\\"\\\"\\\" if isinstance(cat_priority, str) or not (isinstance(cat_priority, Iterable)):\",\n \"of the input vColumn based on an aggregation. Parameters ----------\",\n \"self.transformations += [(new_column, ctype, category)] try: sauv = {} for\",\n \"custom_lines, columns, title=by, loc=\\\"center left\\\", bbox_to_anchor=[1, 0.5], ) ax.set_xlabel(self.alias) return\",\n \"the Median will be drawn. ax: Matplotlib axes object, optional\",\n \"None else \\\"NULL\\\", ) for elem in result if elem[2]\",\n \"{}).\\\".format(self.alias, y) result = to_tablesample(query, title=title) result.values[\\\"index\\\"] += [\\\"total\\\"] result.values[\\\"non_events\\\"]\",\n \"{} FROM {} LIMIT 1\\\".format( new_column.format(self.alias), self.parent.__genSQL__() ), print_time_sql=False, )\",\n \"**style_kwds, ) # ---# def std(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the\",\n \"method.lower() if method == \\\"auto\\\": pre_comp = self.parent.__get_catalog_value__(self.alias, \\\"numh\\\") if\",\n \"vColumn. transformations, str : List of the different transformations. \\\"\\\"\\\"\",\n \"-------- vDataFrame.aggregate : Computes the vDataFrame input aggregations. \\\"\\\"\\\" check_types(\",\n \"\\\"\\\" query = \\\"SELECT {} AS {}, COUNT(*) AS _verticapy_cnt_,\",\n \"bins with the same number of elements. same_width : Computes\",\n \"{} {} largest elements.\\\".format(self.alias, n) return to_tablesample(query, title=title) # ---#\",\n \"dict = {} ): self.parent, self.alias, self.transformations = ( parent,\",\n \"[str]), (\\\"of\\\", of, [str]), (\\\"max_cardinality\\\", max_cardinality, [list]), (\\\"h\\\", h, [list,\",\n \"--------------------------------------------------------------------------- Returns True if the vColumn is boolean, False otherwise.\",\n \"a customized expression. \\\"\\\"\\\" check_types([(\\\"name\\\", name, [str])]) name = quote_ident(name.replace('\\\"',\",\n \"== 1) else str(int(n)) if isinstance(top, decimal.Decimal): top = float(top)\",\n \"[item[0] for item in result], \\\"count\\\": [int(item[1]) for item in\",\n \"str, optional The method used for the plot. gaussian :\",\n \"vColumn. vDataFrame[].str_replace : Replaces the regular expression matches in each\",\n \"{}.\\\".format(self.alias), method=\\\"fetchfirstelem\\\", ) self.parent.__update_catalog__( {\\\"index\\\": [\\\"store_usage\\\"], self.alias: [store_usage]} ) return\",\n \"pre_comp != \\\"VERTICAPY_NOT_PRECOMPUTED\\\": if not (dropna) and (pre_comp != None):\",\n \"try: query = \\\"SELECT {}::{} AS {} FROM {} WHERE\",\n \"for column in by]) ) if (by) else \\\"\\\" )\",\n \"is_date = ( self.nunique(), self.isnum(), self.isdate(), ) if (is_date) and\",\n \"is null !\\\".format( self.alias ) warnings.warn(warning_message, Warning) return self elif\",\n \"x ORDER BY verticapy_agg DESC\\\".format( self.alias, bin_spatial_to_str(self.category(), self.alias), self.alias, kwargs[\\\"agg\\\"],\",\n \"using the input method. \\\"\\\"\\\" check_types([(\\\"lower\\\", lower, [float, int]), (\\\"upper\\\",\",\n \"depending on the input method. Parameters ---------- method: str, optional\",\n \"an aggregation. \\\"\\\"\\\" check_types( [ (\\\"by\\\", by, [str]), (\\\"kernel\\\", kernel,\",\n \"numerical column for each vColumn category. In this case, the\",\n \"DESC\\\" partition_by = ( \\\"PARTITION BY {}\\\".format( \\\", \\\".join([quote_ident(column) for\",\n \": Regular pie chart. donut : Donut chart. rose :\",\n \"if result[i][2] == None: pass elif math.isnan(result[i][2]): result[i][2] = None\",\n \"mean_alpha = \\\"NULL\\\" if mean_1_alpha == None: mean_alpha = \\\"NULL\\\"\",\n \"method 'robust_zscore' is available only if the parameter 'by' is\",\n \"return_trans: bool = False ): \\\"\\\"\\\" --------------------------------------------------------------------------- Normalizes the input\",\n \"vColumn nth most occurent element. See Also -------- vDataFrame.aggregate :\",\n \"{} GROUP BY {}\\\".format( by[0], self.alias, self.alias, self.parent.__genSQL__(), by[0], ),\",\n \"{op1} {column} AND {column} {op2} '{second_elem}' THEN '{label}'\\\" ] expr\",\n \"\\\"same_freq\\\": assert nbins >= 2, ParameterError( \\\"Parameter 'nbins' must be\",\n \"set to True, the method will return the transformation used\",\n \"def aggregate(self, func: list): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using\",\n \"= 0.25) AS 'approx_25%', APPROXIMATE_PERCENTILE ({3}{4} USING PARAMETERS percentile =\",\n \"split_value::float\\\".format( \\\" UNION ALL \\\".join(query), nbins - 1 ) result\",\n \"empty in case of discretization using the method 'smart'.\\\" )\",\n \"AS non_events, SUM({}) AS events FROM ({}) x GROUP BY\",\n \"Returns ------- list Distinct caterogies of the vColumn. See Also\",\n \"number of digits after the comma. Parameters ---------- n: int\",\n \"float]), ] ) if use_threshold: result = self.aggregate(func=[\\\"std\\\", \\\"avg\\\"]).transpose().values self.parent.filter(\",\n \"if mean_alpha == None: mean_alpha = \\\"NULL\\\" if mean_1_alpha ==\",\n \".values[self.alias] ) result = [distinct_count] + result index = [\",\n \") transformations = self.transformations + [(expr, \\\"bool\\\", \\\"int\\\")] new_vColumn =\",\n \"kwargs[\\\"column\\\"] else: check = False if check: self.parent.are_namecols_in(column) column =\",\n \"= [ \\\"unique\\\", \\\"count\\\", \\\"mean\\\", \\\"std\\\", \\\"min\\\", \\\"approx_25%\\\", \\\"approx_50%\\\", \\\"approx_75%\\\",\",\n \"\\\\_______/ / / # ______ / / # \\\\ /\",\n \"is equal to 0, an optimised interval will be computed.\",\n \"/ int(nbins))) assert nb != 0, Exception( \\\"Not enough values\",\n \"query = \\\"SELECT split_value FROM (SELECT split_value, MAX(weighted_information_gain) FROM ({})\",\n \"Returns True if the vColumn is boolean. vDataFrame[].isnum : Returns\",\n \"optional If not empty, a copy will be created using\",\n \"= method.lower() if self.isnum() and method == \\\"smart\\\": schema =\",\n \"copy_trans] for elem in sauv: self.catalog[elem] = sauv[elem] return self.parent\",\n \"series rule. Parameters ---------- length: int Slice size. unit: str,\",\n \"LIMIT 1\\\".format( cmax, cmin, self.parent.__genSQL__() ), print_time_sql=False, ) except: cmax,\",\n \"vDataFrame[].nlargest : Returns the n largest vColumn elements. \\\"\\\"\\\" check_types([(\\\"n\\\",\",\n \"elem[1] != None else \\\"NULL\\\", ) for elem in result\",\n \"to use iv_woe.\\\".format(y) ) response_cat = self.parent[y].distinct() response_cat.sort() assert response_cat\",\n \"), method=\\\"fetchall\\\", ) cmin = \\\"DECODE({}, {}, NULL)\\\".format( by[0], \\\",\",\n \"elif method == \\\"topk\\\": assert k >= 2, ParameterError( \\\"Parameter\",\n \"for elem in result] ), ) executeSQL( \\\"SELECT {} FROM\",\n \"h > 0.01: h = round(h, 2) elif h >\",\n \"True if the vColumn is boolean. See Also -------- vDataFrame[].isdate\",\n \"(\\\"start\\\", start, [bool]), ] ) start_or_end = \\\"START\\\" if (start)\",\n \"vColumn using the mean encoding of a response. \\\"\\\"\\\" if\",\n \"query, ) title = \\\"Computing WOE & IV of {}\",\n \"method will return the mode of the vColumn. Returns -------\",\n \"percent, AVG({3}{4}) AS mean, STDDEV({3}{4}) AS std, MIN({3}{4}) AS min,\",\n \"a response. \\\"\\\"\\\" if self.category() in [\\\"date\\\", \\\"float\\\"]: warning_message =\",\n \"assert response, ParameterError( \\\"Parameter 'response' can not be empty in\",\n \"---------- method: str, optional The method to use to aggregate\",\n \"TypeError( \\\"The response column must be numerical to use a\",\n \"the vColumn (only if the vColumn type is date like).\",\n \"\\\\ \\\\ \\\\____ \\\\ \\\\ \\\\/\\\\ \\\\ \\\\ \\\\ \\\\____\",\n \"= 6, numcol: str = \\\"\\\" ): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates\",\n \"\\\"[Normalize]: The vColumn '{}' was normalized with the method '{}'.\\\".format(\",\n \"OFFSET {1}) VERTICAPY_SUBTABLE) ORDER BY count DESC\\\" ).format(self.alias, max_cardinality +\",\n \"{}::int AS {} FROM {}\\\".format( trans, self.alias, self.alias, y, y,\",\n \"val) elif expr: new_column = \\\"COALESCE({}, {})\\\".format(\\\"{}\\\", expr) elif method\",\n \"records by an input value. vDataFrame[].str_slice : Slices the vColumn.\",\n \"'{}' was transformed with the func 'x -> {}'.\\\".format( self.alias.replace('\\\"',\",\n \"the vColumn is numerical or of type date like. Optimized\",\n \"(int(sauv[\\\"count\\\"]) + total) / self.parent.shape()[0] ) except: pass total =\",\n \"str, q: tuple = (0.25, 0.75), start_date: Union[str, datetime.datetime, datetime.date]\",\n \"Parameters ---------- length: int Slice size. unit: str, optional Slice\",\n \"offset=-1) # ---# def topk(self, k: int = -1, dropna:\",\n \"({3}{4} USING PARAMETERS percentile = 0.5) AS 'approx_50%', APPROXIMATE_PERCENTILE ({3}{4}\",\n \"compute the aggregation. max_cardinality: int, optional Maximum number of the\",\n \"Also -------- vDataFrame[].hist : Draws the histogram of the vColumn\",\n \"1 or parameter 'labels' must be empty.\\\" ) conditions, column\",\n \"Gaussian distribution to identify outliers. After normalizing the data (Z-Score),\",\n \") ] if mean_alpha == None: mean_alpha = \\\"NULL\\\" if\",\n \"APPROXIMATE_PERCENTILE({} USING PARAMETERS percentile = 0.25) AS Q1, APPROXIMATE_PERCENTILE({} USING\",\n \"5, offset: int = 0): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns a part\",\n \"count, 100 * COUNT({1}) / {2} AS percent, AVG({3}{4}) AS\",\n \"AS mean, STDDEV({3}{4}) AS std, MIN({3}{4}) AS min, APPROXIMATE_PERCENTILE ({3}{4}\",\n \"{\\\"index\\\": [\\\"store_usage\\\"], self.alias: [store_usage]} ) return store_usage # ---# def\",\n \"one of its affiliates. # Licensed under the Apache License,\",\n \"'{}', '{}')\\\".format( \\\"{}\\\", length, unit.upper(), start_or_end ) ) # ---#\",\n \"* ({})\\\".format(\\\"{}\\\", x)) # ---# def nlargest(self, n: int =\",\n \"vColumn using 'min' (Minimum). Returns ------- float/str minimum See Also\",\n \"function has two arguments (example, power or mod), 'x' represents\",\n \"method ) ) else: raise TypeError(\\\"The vColumn must be numerical\",\n \"= [self.alias, by] else: columns = [self.alias] if of: self.parent.are_namecols_in(of)\",\n \": Computes the Information Value (IV) Table. \\\"\\\"\\\" check_types([(\\\"y\\\", y,\",\n \"def count(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using 'count' (Number\",\n \"bool = False, step: bool = False, ax=None, **style_kwds, ):\",\n \"issue.\\\" ) self.add_copy(new_name) parent = self.drop(add_history=False) parent.__add_to_history__( \\\"[Rename]: The vColumn\",\n \"method == \\\"0ifnull\\\": new_column = \\\"DECODE({}, NULL, 0, 1)\\\" elif\",\n \"alias. Returns ------- vDataFrame self.parent See Also -------- vDataFrame.add_copy :\",\n \"nbins >= 2, ParameterError( \\\"Parameter 'nbins' must be greater or\",\n \"self.aggregate([\\\"mad\\\"]).values[self.alias][0] # ---# def max(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn\",\n \"using 'unique' (cardinality). Parameters ---------- approx: bool, optional If set\",\n \"n = \\\"\\\" if (n == 1) else str(int(n)) if\",\n \"def plot( self, ts: str, by: str = \\\"\\\", start_date:\",\n \"\\\"density\\\", of: str = \\\"\\\", max_cardinality: int = 6, nbins:\",\n \"in func) or ( re.search( re.compile(\\\"\\\\\\\\b{}\\\\\\\\b\\\".format(column.replace('\\\"', \\\"\\\"))), func ) ):\",\n \"upper, upper) if (isinstance(upper, (float, int))) else \\\"\\\" ) func\",\n \"if (category in (\\\"None\\\", None)) else \\\" WHERE {} =\",\n \"(x - median) / (1.4826 * mad) minmax : Normalization\",\n \"set to True, the intervals will be closed on the\",\n \"Dropping a vColumn can make the vDataFrame \\\"heavier\\\" if it\",\n \"- median) / (1.4826 * mad) minmax : Normalization using\",\n \"{}\\\".format( \\\", \\\".join([quote_ident(column) for column in by]) ) if (by)\",\n \"str, optional If not empty, a copy will be created\",\n \"] ) if by: self.parent.are_namecols_in(by) by = self.parent.format_colnames(by) from verticapy.plot\",\n \"name=\\\"model\\\") assert nbins >= 2, ParameterError( \\\"Parameter 'nbins' must be\",\n \"cosine cosh : hyperbolic cosine cot : trigonometric cotangent exp\",\n \"minmax : Normalization using the MinMax (min and max). (x\",\n \"bin_spatial_to_str(self.category(), self.alias), self.alias, self.parent.__genSQL__(), self.alias, self.alias, self.alias, ) else: query\",\n \"a mean encoding\\\" ) max_floor = len(self.parent[response].transformations) - len( self.transformations\",\n \"--------------------------------------------------------------------------- Returns True if the vColumn category is date, False\",\n \"type. \\\"\\\"\\\" return self.transformations[-1][1].lower() dtype = ctype # ---# def\",\n \": Computes the vDataFrame input aggregations. \\\"\\\"\\\" return self.aggregate(func=[\\\"prod\\\"]).values[self.alias][0] prod\",\n \"Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].decode : Encodes\",\n \"type. Returns ------- vDataFrame self.parent See Also -------- vDataFrame.astype :\",\n \"or greater than quantile(1-alpha) will be dropped. Returns ------- vDataFrame\",\n \"\\\"(\\\", \\\")\\\" else: lp, rp = \\\"\\\", \\\"\\\" for category\",\n \"== \\\"categorical\\\")) or ( method == \\\"is_numeric\\\" ): self.parent.__update_catalog__({\\\"index\\\": index,\",\n \"Error happened during the filling.\\\".format(e)) if total > 0: try:\",\n \") for k in range(len(distinct_elements) - n): name = (\",\n \"Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].slice : Slices\",\n \"final transformation. Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].decode\",\n \"method to use to aggregate the data. count : Number\",\n \"(\\\"by\\\", by, [str]), (\\\"max_cardinality\\\", max_cardinality, [int, float]), (\\\"h\\\", h, [int,\",\n \"[str(total)] total += nb where = \\\"WHERE _verticapy_row_nb_ IN ({})\\\".format(\",\n \"---# def hist( self, method: str = \\\"density\\\", of: str\",\n \"{}) / ({})\\\".format(self.alias, med, mad) else: final_transformation = [ (\",\n \"[self.alias] if of: self.parent.are_namecols_in(of) of = self.parent.format_colnames(of) from verticapy.plot import\",\n \"user-specified rule. Parameters ---------- val: int/float/str, optional Value to use\",\n \"transformations. \\\"\\\"\\\" # # Special Methods # # ---# def\",\n \"\\\\_____\\\\ \\\\ \\\\_____\\\\ \\\\ \\\\_____\\\\ \\\\ \\\\_____\\\\ \\\\ \\\\_\\\\ \\\\\",\n \"\\\"The method 'robust_zscore' is available only if the parameter 'by'\",\n \"\\\"sqrt\\\", \\\"tan\\\", \\\"tanh\\\", ], ), (\\\"x\\\", x, [int, float]), ]\",\n \"in distinct ] ), bin_spatial_to_str(self.category()), new_category.replace(\\\"'\\\", \\\"''\\\"), ), \\\"varchar\\\", \\\"text\\\",\",\n \"identify outliers. After normalizing the data (Z-Score), if the absolute\",\n \"bool = True, right: bool = True, ): \\\"\\\"\\\" ---------------------------------------------------------------------------\",\n \"seen as one column of that relation. vColumns simplify several\",\n \"if not (dropna) and (pre_comp != None): return pre_comp assert\",\n \"an offset and a limit). Parameters ---------- limit: int, optional\",\n \"0 self.catalog[\\\"std\\\"] = 1 elif method == \\\"minmax\\\": self.catalog[\\\"min\\\"] =\",\n \"occur, and other statistical information. Parameters ---------- k: int, optional\",\n \"limit: int, optional Number of elements to display. Returns -------\",\n \"vDataFrame[].fill_outliers : Fills the vColumn outliers using the input method.\",\n \"only works on numerical / date-like vColumns.\\\" ) assert len(breaks)\",\n \"---# def discretize( self, method: str = \\\"auto\\\", h: float\",\n \"If set to True, the approximate median is returned. By\",\n \"self.alias, self.alias, self.parent.__genSQL__() ) query = \\\"SELECT COUNT({}) AS NAs,\",\n \"the parameter 'new_name', you'll be able to solve this issue.\\\"\",\n \"MAX(weighted_information_gain) FROM ({}) VERTICAPY_SUBTABLE WHERE split_value IS NOT NULL GROUP\",\n \"like (date, datetime ...), the parameter 'x' will represent the\",\n \"check_types( [(\\\"method\\\", method, [\\\"sturges\\\", \\\"freedman_diaconis\\\", \\\"fd\\\", \\\"auto\\\"])] ) method =\",\n \"outliers.\\\".format( self.alias ), method=\\\"fetchall\\\", ) ] if mean_alpha == None:\",\n \"a RF Classifier otherwise. Example: Write {\\\"n_estimators\\\": 20, \\\"max_depth\\\": 10}\",\n \"[list, float, int]), ] ) if by: self.parent.are_namecols_in(by) by =\",\n \": Encodes the vColumn with user defined Encoding. vDataFrame[].get_dummies :\",\n \"== \\\"categorical\\\"): result = self.aggregate([\\\"count\\\", \\\"min\\\", \\\"max\\\"]) index = result.values[\\\"index\\\"]\",\n \"It supports the # entire data science life cycle, uses\",\n \"\\\"_\\\") if not (prefix) else prefix.replace('\\\"', \\\"_\\\") + prefix_sep.replace('\\\"', \\\"_\\\")\",\n \"[ \\\"abs\\\", \\\"acos\\\", \\\"asin\\\", \\\"atan\\\", \\\"cbrt\\\", \\\"ceil\\\", \\\"cos\\\", \\\"cosh\\\", \\\"cot\\\",\",\n \"vColumn using 'kurtosis'. Returns ------- float kurtosis See Also --------\",\n \"( re.search( re.compile(\\\"\\\\\\\\b{}\\\\\\\\b\\\".format(column.replace('\\\"', \\\"\\\"))), func ) ): max_floor = max(\",\n \"# __ __ ______ ______ __ __ __ __ __\",\n \"int))) else \\\"\\\" ) func = \\\"(CASE {}{}ELSE {} END)\\\".format(lower_when,\",\n \"NOT NULL ORDER BY {} DESC LIMIT {}\\\".format( self.parent.__genSQL__(), self.alias,\",\n \"[str]), (\\\"nbins\\\", nbins, [int, float]), ( \\\"method\\\", method, [\\\"auto\\\", \\\"smart\\\",\",\n \"self.parent.__genSQL__() ) query = \\\"SELECT COUNT({}) AS NAs, MIN({}) AS\",\n \"= None, ax=None, **style_kwds, ): \\\"\\\"\\\" --------------------------------------------------------------------------- Draws the vColumn\",\n \"'name' must not be empty\\\" ) assert not (self.parent.is_colname_in(name)), NameError(\",\n \"root ceil : value up to the next whole number\",\n \"int, optional Number of nbins. If empty, an optimized number\",\n \"+ index, \\\"value\\\": [self.alias, self.ctype()] + result, } if ((is_date)\",\n \": Returns True if the vColumn category is date. \\\"\\\"\\\"\",\n \"/ # / / # / / # \\\\ /\",\n \"NULL))\\\".format( \\\"{}\\\", by[0], \\\", \\\".join( [\\\"{}, {}\\\".format(elem[0], elem[1]) for elem\",\n \"[str(count)]) ) query = \\\"SELECT {} FROM (SELECT {}, ROW_NUMBER()\",\n \"self.parent.__update_catalog__( {\\\"index\\\": [\\\"top{}\\\".format(n)], self.alias: [top]} ) return top # ---#\",\n \"float average See Also -------- vDataFrame.aggregate : Computes the vDataFrame\",\n \"func=\\\"REGEXP_COUNT({}, '{}') > 0\\\".format(\\\"{}\\\", pat.replace(\\\"'\\\", \\\"''\\\")) ) # ---# def\",\n \"used as categorical (No h will be picked or computed)\",\n \"it in the final generated SQL code. Note: Dropping a\",\n \"\\\"\\\"\\\" --------------------------------------------------------------------------- Rounds the vColumn by keeping only the input\",\n \"column to find the most relevant interval to use for\",\n \"self.parent.are_namecols_in(by) by = self.parent.format_colnames(by) nullifzero, n = 1, len(by) if\",\n \"pre_comp = self.parent.__get_catalog_value__(self.alias, \\\"top\\\") if pre_comp != \\\"VERTICAPY_NOT_PRECOMPUTED\\\": if not\",\n \"== 0: op1, close_l = \\\"<\\\", \\\"]\\\" if labels: label\",\n \"self.alias, ) else: query = \\\"SELECT {} FROM (SELECT {}\",\n \"expr: str, optional SQL expression. by: list, optional vColumns used\",\n \"limit). Parameters ---------- limit: int, optional Number of elements to\",\n \"datetime.date]), (\\\"end_date\\\", end_date, [str, datetime.datetime, datetime.date]), (\\\"area\\\", area, [bool]), (\\\"step\\\",\",\n \"{}, \\\"spearmand\\\": {}, \\\"kendall\\\": {}, \\\"cramer\\\": {}, \\\"biserial\\\": {}, \\\"regr_avgx\\\":\",\n \"\\\"Parameter 'k' must be greater or equals to 2 in\",\n \"NULL value. winsorize : Clips the vColumn using as lower\",\n \"and 2 to be used as categorical (No h will\",\n \"return self.aggregate([\\\"max\\\"]).values[self.alias][0] # ---# def mean_encode(self, response: str): \\\"\\\"\\\" ---------------------------------------------------------------------------\",\n \"[list]), (\\\"include_lowest\\\", include_lowest, [bool]), (\\\"right\\\", right, [bool]), ] ) assert\",\n \"GROUP BY {} ORDER BY {}\\\".format( bin_spatial_to_str(self.category(), self.alias), self.alias, self.parent.__genSQL__(),\",\n \"/ / / # |______ / / / # |____/\",\n \"self.alias.replace('\\\"', \\\"\\\") ) ) # ---# def apply_fun(self, func: str,\",\n \"self.aggregate([\\\"sum\\\"]).values[self.alias][0] # ---# def tail(self, limit: int = 5): \\\"\\\"\\\"\",\n \"for elem in sauv: self.catalog[elem] = sauv[elem] return self.parent #\",\n \"(method != \\\"numerical\\\")) or not (is_numeric) or (method == \\\"categorical\\\")\",\n \"an aggregation. \\\"\\\"\\\" check_types( [ (\\\"by\\\", by, [str]), (\\\"method\\\", method,\",\n \"(Variance). Returns ------- float var See Also -------- vDataFrame.aggregate :\",\n \"{} FROM (SELECT {} AS {}, {} AS verticapy_agg FROM\",\n \"See Also -------- vDataFrame[].nsmallest : Returns the n smallest elements\",\n \"args[0] elif \\\"column\\\" in kwargs: column = kwargs[\\\"column\\\"] else: check\",\n \"breaks must be equal to the length of parameter 'labels'\",\n \"vColumn and it returns the new vDataFrame of the search.\",\n \"def sub(self, x: float): \\\"\\\"\\\" --------------------------------------------------------------------------- Subtracts the input element\",\n \"\\\"License\\\"); # You may not use this file except in\",\n \"ts = self.parent.format_colnames(ts) if by: self.parent.are_namecols_in(by) by = self.parent.format_colnames(by) from\",\n \"self.apply(func=\\\"{} / ({})\\\".format(\\\"{}\\\", x)) # ---# def drop(self, add_history: bool\",\n \"4) elif h > 0.000001: h = round(h, 6) if\",\n \"executeSQL( query=query, title=\\\"Computing the distinct categories of {}.\\\".format(self.alias), method=\\\"fetchall\\\", )\",\n \"kurt = kurtosis # ---# def label_encode(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Encodes\",\n \"value down to the next whole number ln : natural\",\n \"method, [\\\"zscore\\\", \\\"robust_zscore\\\", \\\"minmax\\\"]), (\\\"by\\\", by, [list]), (\\\"return_trans\\\", return_trans, [bool]),\",\n \"cosine asin : trigonometric inverse sine atan : trigonometric inverse\",\n \"check_types( [ (\\\"breaks\\\", breaks, [list]), (\\\"labels\\\", labels, [list]), (\\\"include_lowest\\\", include_lowest,\",\n \"/ YEAR Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].slice\",\n \"list, optional vColumns used in the partition. order_by: list, optional\",\n \"See Also -------- vDataFrame[].isbool : Returns True if the vColumn\",\n \"1\\\") where = \\\" WHERE {} IS NOT NULL \\\".format(self.alias)\",\n \"using the input method. Parameters ---------- method: str, optional The\",\n \"\\\"''\\\"), k) ] text_info += \\\"\\\\t{} => {}\\\".format(distinct_elements[k], k) expr\",\n \"\\\"\\\"\\\" --------------------------------------------------------------------------- Returns the k most occurent elements and their\",\n \"sys total = ( sys.getsizeof(self) + sys.getsizeof(self.alias) + sys.getsizeof(self.transformations) +\",\n \"if elem[1] != None else \\\"NULL\\\", ) for elem in\",\n \"\\\"cat_stats\\\") or (numcol), ParameterError( \\\"The parameter 'numcol' must be a\",\n \"= -1, dropna: bool = True): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns the\",\n \"transform the vColumn. The function variable must be composed of\",\n \"\\\".join(expr) + \\\", {})\\\".format(len(distinct_elements)) self.transformations += [(expr, \\\"int\\\", \\\"int\\\")] self.parent.__update_catalog__(erase=True,\",\n \"n == 0: nullifzero = 0 avg, stddev = self.aggregate([\\\"avg\\\",\",\n \"\\\"issue.\\\" ) for k in range(len(distinct_elements) - n): name =\",\n \"the data. method: str, optional The method to use to\",\n \"title=\\\"Testing the Type casting.\\\") self.transformations += [ ( \\\"{}::{}\\\".format(\\\"{}\\\", dtype),\",\n \"if not (dropna): n = \\\"\\\" if (n == 1)\",\n \"sauv[\\\"min\\\"] ) except: pass if method == \\\"robust_zscore\\\": self.catalog[\\\"median\\\"] =\",\n \"See Also -------- vDataFrame[].decode : Encodes the vColumn with a\",\n \"(\\\"numcol\\\", numcol, [str]), ] ) method = method.lower() assert (method\",\n \"vColumn. \\\"\\\"\\\" check_types([(\\\"x\\\", x, [int, float])]) assert x != 0,\",\n \"vColumn missing values. \\\"\\\"\\\" if isinstance(by, str): by = [by]\",\n \"] ) if use_threshold: result = self.aggregate(func=[\\\"std\\\", \\\"avg\\\"]).transpose().values p_alpha, p_1_alpha\",\n \"!= \\\"VERTICAPY_NOT_PRECOMPUTED\\\": if not (dropna) and (pre_comp != None): return\",\n \"__|_. _ _ |_) # \\\\/ (/_| | |(_(_|| \\\\/\",\n \"str = \\\"density\\\", of: str = \\\"\\\", max_cardinality: Union[int, tuple]\",\n \"= False, ax=None, **style_kwds, ): \\\"\\\"\\\" --------------------------------------------------------------------------- Draws the range\",\n \"solve this \\\" \\\"issue.\\\" ) for k in range(len(distinct_elements) -\",\n \"be a cutomized aggregation (ex: AVG(column1) + 5). ax: Matplotlib\",\n \"self, method, of, max_cardinality, h, donut, rose, ax=None, **style_kwds, )\",\n \"Response vColumn. Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].decode\",\n \"Returns the head of the vColumn. vDataFrame[].tail : Returns the\",\n \"y: str, nbins: int = 10): \\\"\\\"\\\" --------------------------------------------------------------------------- Computes the\",\n \"!= None) or (upper != None), ParameterError( \\\"At least 'lower'\",\n \"= \\\"SELECT {}, {}({}) FROM {} GROUP BY {};\\\".format( by[0],\",\n \"'labels' must be empty.\\\" ) conditions, column = [], self.alias\",\n \"\\\"''\\\")) ) # ---# def str_replace(self, to_replace: str, value: str\",\n \"def str_extract(self, pat: str): \\\"\\\"\\\" --------------------------------------------------------------------------- Extracts the regular expression\",\n \"TypeError( \\\"vColumn {} must be binary to use iv_woe.\\\".format(y) )\",\n \"See Also -------- vDataFrame.topk : Returns the vColumn most occurent\",\n \"h, ax=ax, **style_kwds, ) # ---# def std(self): \\\"\\\"\\\" ---------------------------------------------------------------------------\",\n \"to keep after the comma. Returns ------- vDataFrame self.parent See\",\n \"float, optional Uses the Gaussian distribution to define the outliers.\",\n \"self.alias), self.alias, self.parent.shape()[0], self.parent.__genSQL__(), dropna, self.alias, topk, ) result =\",\n \"+= [self.alias] if add_history: self.parent.__add_to_history__( \\\"[Drop]: vColumn {} was deleted\",\n \"Draws the Bar Chart of the input vColumns based on\",\n \"if idx == 0 and include_lowest: op1, close_l = \\\"<=\\\",\",\n \"whereas one vColumn can only have one parent. catalog: dict,\",\n \"-------- vDataFrame[].ctype : Returns the vColumn database type. \\\"\\\"\\\" return\",\n \"e: self.transformations = [elem for elem in copy_trans] raise QueryError(\\\"{}\\\\nAn\",\n \"If not empty, a copy will be created using the\",\n \"1: lp, rp = \\\"(\\\", \\\")\\\" else: lp, rp =\",\n \"method on the vColumn \\\" \\\"or simply because of ambiguous\",\n \"response. \\\"\\\"\\\" check_types( [ (\\\"RFmodel_params\\\", RFmodel_params, [dict]), (\\\"return_enum_trans\\\", return_enum_trans, [bool]),\",\n \"ParameterError( \\\"If the method is in ffill|pad|bfill|backfill then 'order_by' must\",\n \"stored in Vertica, taking advantage Vertica’s # speed and built-in\",\n \"Attributes ---------- alias, str : vColumn alias. catalog, dict :\",\n \"by grouping by elements, please use a method in zscore|minmax\\\"\",\n \"length: int Slice size. unit: str, optional Slice size unit.\",\n \"\\\"regr_intercept\\\": {}, \\\"regr_r2\\\": {}, \\\"regr_slope\\\": {}, \\\"regr_sxx\\\": {}, \\\"regr_sxy\\\": {},\",\n \"CASE ... WHEN vColumn = argv[2 * i] THEN argv[2\",\n \"expr = \\\", \\\".join(expr) + \\\", {})\\\".format(len(distinct_elements)) self.transformations += [(expr,\",\n \"--------------------------------------------------------------------------- Returns True if the vColumn is numerical, False otherwise.\",\n \"as upper bound quantile(1-alpha) if 'use_threshold' is set to False\",\n \"self.alias, self.alias, self.alias, self.parent.__genSQL__(), self.alias, where, ) result = executeSQL(\",\n \"# \\\\/_/ \\\\/_____/ \\\\/_____/ \\\\/_____/ \\\\/_____/ \\\\/_/ \\\\/_/ \\\\/_/ \\\\/_/\",\n \"greater than November 1993 the 3rd. area: bool, optional If\",\n \"equal to the length of parameter 'labels' + 1 or\",\n \"len(self.parent[elem].transformations) max_floor -= len(self.transformations) for k in range(max_floor): self.transformations +=\",\n \"add_copy(self, name: str): \\\"\\\"\\\" --------------------------------------------------------------------------- Adds a copy vColumn to\",\n \"Exception as e: self.transformations = [elem for elem in copy_trans]\",\n \"of the vColumns to use to sort the data when\",\n \"that represents the quantile. For example: 0.25 represents Q1. approx:\",\n \"i in range(len(result)): if result[i][2] == None: pass elif math.isnan(result[i][2]):\",\n \"The interval size to convert to use to convert the\",\n \"(\\\"drop_first\\\", drop_first, [bool]), (\\\"use_numbers_as_suffix\\\", use_numbers_as_suffix, [bool]), ] ) distinct_elements =\",\n \"{}) * {} || ';' || (FLOOR({} / {}) *\",\n \"vDataFrame input aggregations. \\\"\\\"\\\" return self.aggregate([\\\"sem\\\"]).values[self.alias][0] # ---# def skewness(self):\",\n \"Applies a function to the input vColumn. \\\"\\\"\\\" check_types([(\\\"n\\\", n,\",\n \"self.alias, cast, self.parent.__genSQL__(), self.parent.__get_last_order_by__(), index, ) return executeSQL( query=query, title=\\\"Getting\",\n \"NOT NULL LIMIT 0\\\".format( func.replace(\\\"{}\\\", self.alias), self.parent.__genSQL__(), self.alias, ), \\\"apply_test_feature\\\",\",\n \"of the vColumn. The category will be one of the\",\n \"+= ( \\\" WHERE {} IS NULL\\\".format(self.alias) if (category in\",\n \"the vColumn is null, 1 otherwise. expr: str, optional SQL\",\n \"return self.apply(func=\\\"ROUND({}, {})\\\".format(\\\"{}\\\", n)) # ---# def sem(self): \\\"\\\"\\\" ---------------------------------------------------------------------------\",\n \"return self.aggregate(func=[\\\"prod\\\"]).values[self.alias][0] prod = product # ---# def quantile(self, x:\",\n \"), method=\\\"fetchall\\\", ) ] if mean_alpha == None: mean_alpha =\",\n \"check_types( [ (\\\"by\\\", by, [str]), (\\\"kernel\\\", kernel, [\\\"gaussian\\\", \\\"logistic\\\", \\\"sigmoid\\\",\",\n \"the vColumn by dropping the current vColumn and creating a\",\n \"(isinstance(lower, (float, int))) else \\\"\\\" ) upper_when = ( \\\"WHEN\",\n \"(use_numbers_as_suffix) else '\\\"{}{}\\\"'.format( prefix, str(distinct_elements[k]).replace('\\\"', \\\"_\\\") ) ) assert not\",\n \"-------- vDataFrame.aggregate : Computes the vDataFrame input aggregations. \\\"\\\"\\\" check_types([(\\\"approx\\\",\",\n \"[int, float])]) return self.apply(func=\\\"SUBSTR({}, {}, {})\\\".format(\\\"{}\\\", start, step)) # ---#\",\n \"BY {}))\\\".format( \\\"{}\\\", fun, \\\"{}\\\", \\\", \\\".join(by) ) elif method\",\n \"COUNT({1}) AS count, 100 * COUNT({1}) / {2} AS percent,\",\n \"categorical. numcol: str, optional Numerical vColumn to use when the\",\n \"with the func 'x -> {}'.\\\".format( self.alias.replace('\\\"', \\\"\\\"), func.replace(\\\"{}\\\", \\\"x\\\"),\",\n \"= 0 if index_start < 0: index_start += self.parent.shape()[0] if\",\n \"self.min()) * 1.01 / nbins if h > 0.01: h\",\n \"the {}'s lower and upper outliers.\\\".format( self.alias ), method=\\\"fetchall\\\", )\",\n \"in sauv: self.catalog[\\\"count\\\"] = int(sauv[\\\"count\\\"]) + total self.catalog[\\\"percent\\\"] = (\",\n \"allow slicing having steps different than 1.\\\" ) index_stop =\",\n \"ValueError( \\\"vColumn doesn't allow slicing having steps different than 1.\\\"\",\n \"result] ), ) executeSQL( \\\"SELECT {} FROM {} LIMIT 1\\\".format(\",\n \"--------------------------------------------------------------------------- Draws the histogram of the vColumn based on an\",\n \"--------------------------------------------------------------------------- Rounds the vColumn by keeping only the input number\",\n \"copy of the vColumn {} named {} was added to\",\n \"percentile = 0.75) AS 'approx_75%', APPROXIMATE_PERCENTILE ({3}{4} USING PARAMETERS percentile\",\n \"the outliers by the NULL value. winsorize : Clips the\",\n \"smallest elements in the vColumn. \\\"\\\"\\\" check_types([(\\\"n\\\", n, [int, float])])\",\n \"list, *args): \\\"\\\"\\\" --------------------------------------------------------------------------- Looks if some specific records are\",\n \"self.alias), self.parent.__genSQL__(), self.alias, ), \\\"apply_test_feature\\\", ) except: ctype = get_data_types(\",\n \"= gen_colors() if not xlim: xmin = self.min() xmax =\",\n \"\\\"pad\\\")) else \\\" DESC\\\" partition_by = ( \\\"PARTITION BY {}\\\".format(\",\n \"records are in the vColumn and it returns the new\",\n \"query, title=\\\"Computing the top{} categories of {}.\\\".format( k if k\",\n \"check_types( [ (\\\"method\\\", method, [\\\"auto\\\", \\\"numerical\\\", \\\"categorical\\\", \\\"cat_stats\\\"]), (\\\"max_cardinality\\\", max_cardinality,\",\n \"be able to solve this \\\" \\\"issue.\\\" ) for k\",\n \"self.alias, response ) ) if verticapy.options[\\\"print_info\\\"]: print(\\\"The mean encoding was\",\n \"Returns ------- float mad See Also -------- vDataFrame.aggregate : Computes\",\n \"Matplotlib axes object See Also -------- vDataFrame.plot : Draws the\",\n \"_ /~\\\\ _ |. # |_)\\\\/ |_)(_|(_|| \\\\_/|_|(_||| # /\",\n \"get_category_from_vertica_type(ctype=ctype) all_cols, max_floor = self.parent.get_columns(), 0 for column in all_cols:\",\n \"= argv[2 * i] THEN argv[2 * i + 1]\",\n \"input list. Parameters ---------- breaks: list List of values used\",\n \"xlim custom_lines = [] columns = self.parent[by].distinct() for idx, column\",\n \"\\\"\\\"\\\" --------------------------------------------------------------------------- Returns the nth most occurent element. Parameters ----------\",\n \"--------------------------------------------------------------------------- Computes the optimal vColumn bar width. Parameters ---------- method:\",\n \"# ---# def iloc(self, limit: int = 5, offset: int\",\n \"vDataFrame[].tail : Returns the tail of the vColumn. \\\"\\\"\\\" check_types([(\\\"limit\\\",\",\n \"---# def _repr_html_(self): return self.head(limit=verticapy.options[\\\"max_rows\\\"])._repr_html_() # ---# def __setattr__(self, attr,\",\n \"the function's performance can drastically decrease. Returns ------- int vColumn\",\n \"if isinstance(xlim, (tuple, list)): xlim_tmp = [xlim] else: xlim_tmp =\",\n \"\\\"auto\\\", \\\"mode\\\", \\\"0ifnull\\\", \\\"mean\\\", \\\"avg\\\", \\\"median\\\", \\\"ffill\\\", \\\"pad\\\", \\\"bfill\\\", \\\"backfill\\\",\",\n \"= 'tabular'))\\\".format( tmp_model_name, i ) for i in range(parameters[\\\"n_estimators\\\"]) ]\",\n \") distinct = self.topk(k).values[\\\"index\\\"] trans = ( \\\"(CASE WHEN {}\",\n \"compute the optimal h.\\\", method=\\\"fetchrow\\\", ) count, vColumn_min, vColumn_025, vColumn_075,\",\n \"---# def str_count(self, pat: str): \\\"\\\"\\\" --------------------------------------------------------------------------- Computes the number\",\n \"OVER ({} ORDER BY {}))\\\".format( \\\"{}\\\", \\\"{}\\\", partition_by, order_by_ts )\",\n \": average median : median min : minimum mode :\",\n \"except Exception as e: self.transformations = [elem for elem in\",\n \"comma. Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].apply :\",\n \"in order_by] + by) by = self.parent.format_colnames(by) if method ==\",\n \"of {}.\\\".format(self.alias), method=\\\"fetchall\\\", ) return [item for sublist in query_result\",\n \"= True if not (\\\"figsize\\\" in kwargs): kwargs[\\\"figsize\\\"] = (14,\",\n \"+= [(\\\"{}\\\", self.ctype(), self.category())] self.transformations += [(func, ctype, category)] self.parent.__update_catalog__(erase=True,\",\n \"+ \\\", {})\\\".format(len(distinct_elements)) self.transformations += [(expr, \\\"int\\\", \\\"int\\\")] self.parent.__update_catalog__(erase=True, columns=[self.alias])\",\n \"FROM {} GROUP BY {}\\\".format( by[0], self.alias, self.alias, self.parent.__genSQL__(), by[0],\",\n \"0: nullifzero = 0 cmin, cmax = self.aggregate([\\\"min\\\", \\\"max\\\"]).values[self.alias] if\",\n \"the vColumn with user defined Encoding. vDataFrame[].get_dummies : Encodes the\",\n \"Adds a new vColumn to the vDataFrame by using an\",\n \"vDataFrame[].decode : Encodes the vColumn using a user-defined encoding. vDataFrame[].discretize\",\n \"number cos : trigonometric cosine cosh : hyperbolic cosine cot\",\n \"------- vDataFrame self.parent See Also -------- vDataFrame.outliers : Computes the\",\n \"multiple statistical aggregations: min, max, median, unique... depending on the\",\n \"self.apply( func=\\\"REGEXP_COUNT({}, '{}')\\\".format(\\\"{}\\\", pat.replace(\\\"'\\\", \\\"''\\\")) ) # ---# def str_extract(self,\",\n \"Returns the k most occurent elements and their distributions as\",\n \"\\\"\\\"\\\" return self.transformations[-1][2] # ---# def clip(self, lower=None, upper=None): \\\"\\\"\\\"\",\n \"of: str = \\\"\\\", max_cardinality: int = 6, nbins: int\",\n \"self.parent.shape()[0] query = \\\"SELECT {}{} FROM {}{} OFFSET {} LIMIT\",\n \"model.fit(self.parent.__genSQL__(), [self.alias]).plot( ax=ax, **style_kwds ) model.drop() return result except: model.drop()\",\n \"nbins=nbins, xlim=xlim_tmp, store=False, ) try: result = model.fit(self.parent.__genSQL__(), [self.alias]).plot( ax=ax,\",\n \"\\\"\\\"\\\" --------------------------------------------------------------------------- Computes the Information Value (IV) / Weight Of\",\n \"== \\\"categorical\\\") ): query = \\\"\\\"\\\"(SELECT {0} || '', COUNT(*)\",\n \"IQR / n ** (1 / 3)] sturges : Sturges\",\n \"normalize {} using the MIN and the MAX. MAX =\",\n \"= self.catalog[elem] self.parent.__update_catalog__(erase=True, columns=[self.alias]) try: if \\\"count\\\" in sauv: self.catalog[\\\"count\\\"]\",\n \"input vColumn. \\\"\\\"\\\" check_types( [ (\\\"breaks\\\", breaks, [list]), (\\\"labels\\\", labels,\",\n \"tmp_model_name, i ) for i in range(parameters[\\\"n_estimators\\\"]) ] query =\",\n \"median, unique... depending on the input method. Parameters ---------- method:\",\n \"binary / spatial / uuid / undefined Returns ------- str\",\n \"optional If set to True, the approximate cardinality is returned.\",\n \"matplotlib.lines import Line2D colors = gen_colors() if not xlim: xmin\",\n \"None) else \\\"'{}'\\\".format(str(elem[0]).replace(\\\"'\\\", \\\"''\\\")) ) result[idx][1] = \\\"NULL\\\" if (elem[1]\",\n \"False if of: self.parent.are_namecols_in(of) of = self.parent.format_colnames(of) from verticapy.plot import\",\n \"value\\\" ) lower_when = ( \\\"WHEN {} < {} THEN\",\n \"WHEN {} IN ({}) THEN {} || '' ELSE '{}'\",\n \"the vColumn. The vColumn will be transformed. Parameters ---------- pat:\",\n \"k=nbins, new_category=\\\"Others\\\", return_enum_trans=True, )[0].replace(\\\"{}\\\", self.alias) query = \\\"SELECT {} AS\",\n \"[int, float]), (\\\"pie_type\\\", pie_type, [\\\"auto\\\", \\\"donut\\\", \\\"rose\\\"]), ] ) donut\",\n \"\\\"SELECT {} AS {}, COUNT(*) AS _verticapy_cnt_, 100 * COUNT(*)\",\n \"or agreed to in writing, software # distributed under the\",\n \"self.alias, \\\", \\\".join(by) ), \\\"STDDEV({}) OVER (PARTITION BY {})\\\".format( self.alias,\",\n \"\\\"Can not normalize {} using the MIN and the MAX.\",\n \"in values: for i in range(len(values[elem])): if isinstance(values[elem][i], decimal.Decimal): values[elem][i]\",\n \") top = None if not (result) else result[0][0] if\",\n \"\\\"\\\", h: float = 0, max_cardinality: int = 8, cat_priority:\",\n \"[ (\\\"method\\\", method, [str]), (\\\"of\\\", of, [str]), (\\\"max_cardinality\\\", max_cardinality, [int,\",\n \"( \\\"WHEN {} > {} THEN {} \\\".format(\\\"{}\\\", upper, upper)\",\n \"or equals to 2 in case of discretization using the\",\n \"is empty\\\\nIf you want to normalize by grouping by elements,\",\n \"and std). (x - avg) / std robust_zscore : Normalization\",\n \"(\\\"of\\\", of, [str]), (\\\"max_cardinality\\\", max_cardinality, [list]), (\\\"h\\\", h, [list, float,\",\n \"= [xlim] else: xlim_tmp = [] model = KernelDensity( name,\",\n \"the response partitioned by the different vColumn categories. Parameters ----------\",\n \"x: float A float between 0 and 1 that represents\",\n \"'x' will represent the number of seconds, otherwise it will\",\n \"UNION ALL (SELECT AVG({}) FROM vdf_table WHERE {} > {})\\\".format(\",\n \"raise TypeError(\\\"The vColumn must be numerical for Normalization\\\") return self.parent\",\n \"of = self.parent.format_colnames(of) from verticapy.plot import pie return pie( self,\",\n \"/~\\\\ _ |. # |_)\\\\/ |_)(_|(_|| \\\\_/|_|(_||| # / #\",\n \"\\\"spearman\\\": {}, \\\"spearmand\\\": {}, \\\"kendall\\\": {}, \\\"cramer\\\": {}, \\\"biserial\\\": {},\",\n \": Computes the number of matches for the regular expression\",\n \"# # __ __ ______ ______ __ __ __ __\",\n \"if not (\\\"cmap\\\" in kwargs): from verticapy.plot import gen_cmap kwargs[\\\"cmap\\\"]\",\n \"Encoding. vDataFrame[].discretize : Discretizes the vColumn. vDataFrame[].get_dummies : Encodes the\",\n \"of a division operation pow : number raised to the\",\n \"1\\\".format( self.alias, y, y, query, ) query = \\\"SELECT {},\",\n \"if of: self.parent.are_namecols_in(of) of = self.parent.format_colnames(of) from verticapy.plot import spider\",\n \"check_types([(\\\"y\\\", y, [str]), (\\\"nbins\\\", nbins, [int])]) self.parent.are_namecols_in(y) y = self.parent.format_colnames(y)\",\n \"aad See Also -------- vDataFrame.aggregate : Computes the vDataFrame input\",\n \"vDataFrame self.parent See Also -------- vDataFrame[].str_count : Computes the number\",\n \"'by' is empty\\\\nIf you want to normalize by grouping by\",\n \"(dropna) else \\\"\\\" query = \\\"SELECT {} AS {}, COUNT(*)\",\n \"* i + 1] ... END odd : CASE ...\",\n \") result = executeSQL( query=query, title=\\\"Computing the optimized histogram nbins\",\n \"the vColumn type is date like (date, datetime ...), the\",\n \"{} FROM (SELECT {}, COUNT(*) AS _verticapy_cnt_ FROM {}{}GROUP BY\",\n \"- {})\\\".format( self.alias, cmin, \\\"NULLIFZERO\\\" if (nullifzero) else \\\"\\\", cmax,\",\n \"{} missing value{} filled.\\\".format( total, self.alias, conj, ) ) else:\",\n \"min, APPROXIMATE_PERCENTILE ({3}{4} USING PARAMETERS percentile = 0.1) AS 'approx_10%',\",\n \"check_types( [ (\\\"by\\\", by, [str]), (\\\"max_cardinality\\\", max_cardinality, [int, float]), (\\\"h\\\",\",\n \"the parent vDataFrame. This parameter is used for testing purpose.\",\n \"average of the {}'s lower and upper outliers.\\\".format( self.alias ),\",\n \"distinct elements for vColumns 1 and 2 to be used\",\n \"\\\"vColumn {} must be binary to use iv_woe.\\\".format(y) ) self.parent[y].distinct()\",\n \"by {}.\\\".format( numcol, self.alias ) values = to_tablesample(query, title=title).values elif\",\n \"self.isnum(), self.isdate(), ) if (is_date) and not (method == \\\"categorical\\\"):\",\n \"\\\"\\\"\\\" return self.aggregate([\\\"sum\\\"]).values[self.alias][0] # ---# def tail(self, limit: int =\",\n \"== \\\"int\\\": h = int(max(math.floor(h), 1)) floor_end = -1 if\",\n \"the method is in ffill|pad|bfill|backfill then 'order_by' must be a\",\n \"permissions and # limitations under the License. # # |_\",\n \"= { \\\"index\\\": [\\\"name\\\", \\\"dtype\\\"] + index, \\\"value\\\": [self.alias, self.ctype()]\",\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__(\",\n \"except: cmax, cmin = ( \\\"MAX({}) OVER (PARTITION BY {})\\\".format(\",\n \"_ _ |_) # \\\\/ (/_| | |(_(_|| \\\\/ #\",\n \"mean = avg # ---# def bar( self, method: str\",\n \"[] prefix = ( self.alias.replace('\\\"', \\\"\\\") + prefix_sep.replace('\\\"', \\\"_\\\") if\",\n \"BY 2 DESC LIMIT {}) VERTICAPY_SUBTABLE ORDER BY split_value::float\\\".format( \\\"\",\n \"outliers threshold. Values lesser than quantile(alpha) or greater than quantile(1-alpha)\",\n \": Discretizes the vColumn. vDataFrame[].get_dummies : Encodes the vColumn with\",\n \"is boolean. See Also -------- vDataFrame[].isdate : Returns True if\",\n \"self.parent.format_colnames(by) from verticapy.plot import gen_colors from matplotlib.lines import Line2D colors\",\n \"---# def clip(self, lower=None, upper=None): \\\"\\\"\\\" --------------------------------------------------------------------------- Clips the vColumn\",\n \"\\\"\\\"\\\" return self.aggregate([\\\"min\\\"]).values[self.alias][0] # ---# def mode(self, dropna: bool =\",\n \"new_name: str): \\\"\\\"\\\" --------------------------------------------------------------------------- Renames the vColumn by dropping the\",\n \"empty\\\" ) assert not (self.parent.is_colname_in(name)), NameError( f\\\"A vColumn has already\",\n \": Clips the vColumn using as lower bound quantile(alpha) and\",\n \"] ) self.parent.are_namecols_in(ts) ts = self.parent.format_colnames(ts) from verticapy.plot import range_curve_vdf\",\n \"{} > {} THEN {} \\\".format(\\\"{}\\\", upper, upper) if (isinstance(upper,\",\n \"(\\\"order_by\\\", order_by, [list]), ] ) method = method.lower() self.parent.are_namecols_in([elem for\",\n \"n: int, optional Integer corresponding to the offset. For example,\",\n \"equals to 2 in case of discretization using the method\",\n \"the vColumn category is date. See Also -------- vDataFrame[].isbool :\",\n \"\\\"\\\"), func.replace(\\\"{}\\\", \\\"x\\\"), ) ) else: for k in range(max_floor):\",\n \"by: list, optional vColumns used in the partition. return_trans: bool,\",\n \"the vColumns to use to sort the data when using\",\n \"float, int]), ] ) if by: self.parent.are_namecols_in(by) by = self.parent.format_colnames(by)\",\n \"# \\\\ / / / # \\\\/ / / #\",\n \"\\\"\\\"): numcol = self.parent.format_colnames(numcol) assert self.parent[numcol].category() in (\\\"float\\\", \\\"int\\\"), TypeError(\",\n \"otherwise. expr: str, optional SQL expression. by: list, optional vColumns\",\n \"Also -------- vDataFrame.memory_usage : Returns the vDataFrame memory usage. \\\"\\\"\\\"\",\n \"if method == \\\"auto\\\": method = \\\"mean\\\" if (self.isnum() and\",\n \"elements to skip. Returns ------- tablesample An object containing the\",\n \"be picked or computed) nbins: int, optional Number of bins.\",\n \"Geospatial object. Parameters ---------- *args / **kwargs Any optional parameter\",\n \"0\\\".format(\\\"{}\\\", pat.replace(\\\"'\\\", \\\"''\\\")) ) # ---# def str_count(self, pat: str):\",\n \"Slices the vColumn. The vColumn will be transformed. Parameters ----------\",\n \"# ---# def __init__( self, alias: str, transformations: list =\",\n \"on an aggregation. \\\"\\\"\\\" if isinstance(pie_type, str): pie_type = pie_type.lower()\",\n \"in (\\\"freedman_diaconis\\\", \\\"fd\\\"): best_h = fd else: best_h = max(sturges,\",\n \"is a Python library with scikit-like functionality for conducting #\",\n \"for k in range(max_floor): self.transformations += [(\\\"{}\\\", self.ctype(), self.category())] self.transformations\",\n \"IGNORE NULLS) OVER ({} ORDER BY {}))\\\".format( \\\"{}\\\", \\\"{}\\\", partition_by,\",\n \"KernelDensity schema = verticapy.options[\\\"temp_schema\\\"] if not (schema): schema = \\\"public\\\"\",\n \"be trained if the response is numerical (except ints and\",\n \"Q1. approx: bool, optional If set to True, the approximate\",\n \"else: result = ( self.parent.describe( method=\\\"numerical\\\", columns=[self.alias], unique=False ) .transpose()\",\n \"div(self, x: float): \\\"\\\"\\\" --------------------------------------------------------------------------- Divides the vColumn by the\",\n \"optional Number of elements to skip. Returns ------- tablesample An\",\n \"arguments (example, power or mod), 'x' represents the second argument.\",\n \"style_kwds, idx)[\\\"color\\\"], lw=4, ), ] ax.set_title(\\\"KernelDensity\\\") ax.legend( custom_lines, columns, title=by,\",\n \"{} must be binary to use iv_woe.\\\".format(y) ) response_cat =\",\n \") elif self.isdate(): min_date = self.min() table = \\\"(SELECT DATEDIFF('second',\",\n \"(labels), ParameterError( \\\"Length of parameter breaks must be equal to\",\n \"return self.parent # ---# def nsmallest(self, n: int = 10):\",\n \"\\\"\\\"\\\" --------------------------------------------------------------------------- Encodes the vColumn with the One-Hot Encoding algorithm.\",\n \"/ TIME ZONE / TIMEZONE_HOUR / TIMEZONE_MINUTE / WEEK /\",\n \"self.parent # ---# def median( self, approx: bool = True,\",\n \"= \\\" WHERE {} IS NOT NULL \\\".format(self.alias) if (dropna)\",\n \"BY {} ORDER BY _verticapy_cnt_ DESC {}\\\".format( bin_spatial_to_str(self.category(), self.alias), self.alias,\",\n \"using the 'topk' method. RFmodel_params: dict, optional Dictionary of the\",\n \"Combination of Freedman Diaconis and Sturges. freedman_diaconis : Freedman Diaconis\",\n \"bars. It is only valid if the vColumns are numerical.\",\n \"int / float / text / binary / spatial /\",\n \"def max(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using 'max' (Maximum).\",\n \"def aad(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using 'aad' (Average\",\n \"relevant interval to use for the discretization. topk : Keeps\",\n \"to the lower bound itself and the values higher than\",\n \") name = ( name.replace(\\\" \\\", \\\"_\\\") .replace(\\\"/\\\", \\\"_\\\") .replace(\\\",\\\",\",\n \"str = \\\"\\\", method: str = \\\"density\\\", of: str =\",\n \"to {}.\\\".format( self.alias, dtype ) ) return self.parent except Exception\",\n \"the topk most frequent categories and merge the other into\",\n \"Robust Z-Score - The MAD is null !\\\".format( self.alias )\",\n \"vDataFrame has been transformed multiple times, so it's better practice\",\n \"new_column = \\\"DECODE({}, NULL, 0, 1)\\\" elif method in (\\\"mean\\\",\",\n \"sign : arithmetic sign sin : trigonometric sine sinh :\",\n \"method, of, max_cardinality, h, ax=ax, **style_kwds, ) # ---# def\",\n \"If empty, an optimized number of nbins will be computed.\",\n \"= (6, 6), h: Union[int, float, tuple] = (None, None),\",\n \"in sublist] # ---# def div(self, x: float): \\\"\\\"\\\" ---------------------------------------------------------------------------\",\n \"pt_events, CASE WHEN non_events = 0 OR events = 0\",\n \"(quote_ident(column) in func) or ( re.search( re.compile(\\\"\\\\\\\\b{}\\\\\\\\b\\\".format(column.replace('\\\"', \\\"\\\"))), func )\",\n \"on an aggregation. \\\"\\\"\\\" check_types( [ (\\\"by\\\", by, [str]), (\\\"method\\\",\",\n \"axes. ax: Matplotlib axes object, optional The axes to plot\",\n \"than quantile(alpha) or greater than quantile(1-alpha) will be dropped. Returns\",\n \"-> x^2 + 2 use \\\"POWER({}, 2) + 2\\\". copy_name:\",\n \"\\\"date\\\" # ---# def isin(self, val: list, *args): \\\"\\\"\\\" ---------------------------------------------------------------------------\",\n \"The vColumn will be transformed. Parameters ---------- field: str The\",\n \"] # ---# def range_plot( self, ts: str, q: tuple\",\n \"* ZEROIFNULL(LN(pt_non_events / NULLIFZERO(pt_events))) END AS iv FROM ({}) x\",\n \"\\\"{}\\\", \\\"{}\\\", partition_by, order_by_ts ) if method in (\\\"mean\\\", \\\"median\\\")\",\n \"1: pre_comp = self.parent.__get_catalog_value__(self.alias, \\\"top\\\") if pre_comp != \\\"VERTICAPY_NOT_PRECOMPUTED\\\": if\",\n \"spatial / uuid / undefined Returns ------- str vColumn category.\",\n \"[str]), (\\\"max_cardinality\\\", max_cardinality, [list]), (\\\"h\\\", h, [list, float, int]), ]\",\n \"\\\"\\\"\\\" --------------------------------------------------------------------------- Draws the pie chart of the vColumn based\",\n \"dict, optional Method to use to impute the missing values.\",\n \"TS methods. Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].dropna\",\n \"by[0], \\\", \\\".join( [\\\"{}, {}\\\".format(elem[0], elem[1]) for elem in result]\",\n \"data transformation operations, and offers beautiful graphical options. # #\",\n \"str = \\\"gaussian\\\", nbins: int = 200, xlim: tuple =\",\n \"sum std : standard deviation topk : kth most occurent\",\n \"self.alias, ) query_result = executeSQL( query=query, title=\\\"Computing the distinct categories\",\n \"# ---# def apply_fun(self, func: str, x: float = 2):\",\n \"aggregations.\\\", method=\\\"fetchall\\\", ) for idx, elem in enumerate(result): result[idx][0] =\",\n \"in range(len(distinct_elements) - n): name = ( '\\\"{}{}\\\"'.format(prefix, k) if\",\n \"if by: self.parent.are_namecols_in(by) by = self.parent.format_colnames(by) columns = [self.alias, by]\",\n \"as Response Column.\\\".format( self.alias, response ) ) if verticapy.options[\\\"print_info\\\"]: print(\\\"The\",\n \"bound itself and the values higher than the upper bound\",\n \"= 1 / 1.4826 elif method == \\\"zscore\\\": self.catalog[\\\"mean\\\"] =\",\n \"vDataFrame[].drop_outliers : Drops outliers in the vColumn. vDataFrame.outliers : Adds\",\n \"result + [self.max()] elif method == \\\"topk\\\": assert k >=\",\n \"in (\\\"mean\\\", \\\"avg\\\", \\\"median\\\"): fun = \\\"MEDIAN\\\" if (method ==\",\n \"to use for the discretization. topk : Keeps the topk\",\n \"return ts_plot( self, ts, by, start_date, end_date, area, step, ax=ax,\",\n \"vColumn. \\\"\\\"\\\" return self.parent.aggregate(func=func, columns=[self.alias]).transpose() agg = aggregate # ---#\",\n \"the Time Series of the vColumn. Parameters ---------- ts: str\",\n \"hyperbolic tangent x: int/float, optional If the function has two\",\n \"\\\"WHEN {} > {} THEN {} \\\".format(\\\"{}\\\", upper, upper) if\",\n \"from verticapy.plot import gen_colors kwargs[\\\"color\\\"] = gen_colors()[0] if not (\\\"legend\\\"\",\n \"elem[1] != None ] ), ) cmax = \\\"DECODE({}, {},\",\n \"threshold, [int, float]), ] ) if use_threshold: result = self.aggregate(func=[\\\"std\\\",\",\n \"simply because of ambiguous columns naming.\\\\nBy changing one of \\\"\",\n \"self.ctype(), self.category())] self.transformations += [ (\\\"AVG({}) OVER (PARTITION BY {})\\\".format(response,\",\n \"self.alias, \\\", \\\".join(by) ), \\\"MIN({}) OVER (PARTITION BY {})\\\".format( self.alias,\",\n \"self.parent.shape()[0], numcol, cast, ) tmp_query += ( \\\" WHERE {}\",\n \"the vColumn using 'aad' (Average Absolute Deviation). Returns ------- float\",\n \": Applies functions to the input vColumns. vDataFrame.applymap : Applies\",\n \"the vColumns. vDataFrame.eval : Evaluates a customized expression. \\\"\\\"\\\" if\",\n \"def avg(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using 'avg' (Average).\",\n \"the most relevant interval to use for the discretization. topk\",\n \"the vColumns outliers using the input method. Parameters ---------- method:\",\n \"object \\\"\\\"\\\" columns = [self.alias] check = True if len(args)\",\n \"(\\\"h\\\", h, [list, float, int]), ] ) if by: self.parent.are_namecols_in(by)\",\n \"self.isdate(), ParameterError( \\\"numh is only available on type numeric|date\\\" )\",\n \"\\\"[Rename]: The vColumn {} was renamed '{}'.\\\".format(old_name, new_name) ) return\",\n \"* sauv[\\\"mad\\\"] ) elif method == \\\"zscore\\\": self.catalog[elem] = (sauv[elem]\",\n \"{} THEN {} ELSE {} END)\\\".format( \\\"{}\\\", p_alpha, mean_alpha, \\\"{}\\\",\",\n \"!= \\\"VERTICAPY_NOT_PRECOMPUTED\\\": return pre_comp store_usage = executeSQL( \\\"SELECT ZEROIFNULL(SUM(LENGTH({}::varchar))) FROM\",\n \"bound. upper: float, optional Upper bound. Returns ------- vDataFrame self.parent\",\n \"Lower bound. upper: float, optional Upper bound. Returns ------- vDataFrame\",\n \"self.transformations += [(\\\"{}\\\", self.ctype(), self.category())] self.transformations += [ (\\\"AVG({}) OVER\",\n \"+= [name] all_new_features += [name] conj = \\\"s were \\\"\",\n \"Exception as e: raise ConversionError( \\\"{}\\\\nThe vColumn {} can not\",\n \"cardinality (or approximate cardinality). See Also -------- vDataFrame.aggregate : Computes\",\n \"product(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using 'product'. Returns -------\",\n \"mean encoding of a response. \\\"\\\"\\\" check_types( [ (\\\"RFmodel_params\\\", RFmodel_params,\",\n \"of parameter 'breaks' must be greater or equal to 2.\\\"\",\n \"Aggregates the vColumn using 'skewness'. Returns ------- float skewness See\",\n \"[str]), (\\\"by\\\", by, [list]), (\\\"order_by\\\", order_by, [list]), ] ) method\",\n \"largest vColumn elements. Parameters ---------- n: int, optional Offset. Returns\",\n \"\\\"{}\\\", p_1_alpha, mean_1_alpha, \\\"{}\\\" ) ) return self.parent # ---#\",\n \"column = args[0] elif \\\"column\\\" in kwargs: column = kwargs[\\\"column\\\"]\",\n \"[elem for elem in copy_trans] for elem in sauv: self.catalog[elem]\",\n \"is boolean. vDataFrame[].isnum : Returns True if the vColumn is\",\n \"self.parent.are_namecols_in(y) y = self.parent.format_colnames(y) assert self.parent[y].nunique() == 2, TypeError( \\\"vColumn\",\n \"using the average of the response partitioned by the different\",\n \"), ) else: cmax, cmin = ( \\\"MAX({}) OVER (PARTITION\",\n \"Encoding. vDataFrame[].get_dummies : Encodes the vColumn with One-Hot Encoding. vDataFrame[].mean_encode\",\n \"for idx in range(len(breaks) - 1): first_elem, second_elem = breaks[idx],\",\n \"on a specific vColumn. \\\"\\\"\\\" return self.parent.aggregate(func=func, columns=[self.alias]).transpose() agg =\",\n \"import Union # VerticaPy Modules import verticapy from verticapy.utilities import\",\n \"vDataFrame.add_copy : Creates a copy of the vColumn. \\\"\\\"\\\" check_types([(\\\"new_name\\\",\",\n \"\\\"cat_stats\\\"]), (\\\"max_cardinality\\\", max_cardinality, [int, float]), (\\\"numcol\\\", numcol, [str]), ] )\",\n \"otherwise. Example: Write {\\\"n_estimators\\\": 20, \\\"max_depth\\\": 10} to train a\",\n \"by: str = \\\"\\\", method: str = \\\"density\\\", of: str\",\n \"columns=[self.alias]) self.parent.__add_to_history__( \\\"[Apply]: The vColumn '{}' was transformed with the\",\n \") ) return self.parent # ---# def mad(self): \\\"\\\"\\\" ---------------------------------------------------------------------------\",\n \"Also -------- vDataFrame[].dropna : Drops the vColumn missing values. \\\"\\\"\\\"\",\n \"regular expression matches in each of the vColumn records by\",\n \"vDataFrame.aggregate : Computes the vDataFrame input aggregations. \\\"\\\"\\\" return self.aggregate([\\\"kurtosis\\\"]).values[self.alias][0]\",\n \"Computes the vDataFrame input aggregations. \\\"\\\"\\\" return self.aggregate([\\\"count\\\"]).values[self.alias][0] # ---#\",\n \"record will be sliced using the floor of the slicing\",\n \"check_types([(\\\"lower\\\", lower, [float, int]), (\\\"upper\\\", upper, [float, int])]) assert (lower\",\n \"---# def ctype(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns the vColumn DB type.\",\n \"--------------------------------------------------------------------------- Looks if some specific records are in the vColumn\",\n \"bins will be computed. h: float, optional Interval width of\",\n \"# /\\\\ \\\\ / / /\\\\ ___\\\\ /\\\\ __ \\\\\",\n \"transformed with the func 'x -> {}'.\\\".format( copy_name.replace('\\\"', \\\"\\\"), func.replace(\\\"{}\\\",\",\n \"# # # ---# class vColumn(str_sql): \\\"\\\"\\\" --------------------------------------------------------------------------- Python object\",\n \"Chart of the input vColumns based on an aggregation. \\\"\\\"\\\"\",\n \"FROM vdf_table GROUP BY {0} ORDER BY COUNT(*) DESC LIMIT\",\n \"func=\\\"TIME_SLICE({}, {}, '{}', '{}')\\\".format( \\\"{}\\\", length, unit.upper(), start_or_end ) )\",\n \"Fills the vColumns outliers using the input method. Parameters ----------\",\n \"\\\" was \\\" self.parent.__add_to_history__( \\\"[Get Dummies]: One hot encoder was\",\n \"(\\\"cmap\\\" in kwargs): from verticapy.plot import gen_cmap kwargs[\\\"cmap\\\"] = gen_cmap()[0]\",\n \"trees and a maximum depth of 10. response: str, optional\",\n \"Random Forest on a response column to find the most\",\n \"method=\\\"fetchall\\\", ) return [item for sublist in query_result for item\",\n \"warnings.warn(warning_message, Warning) else: distinct_elements = self.distinct() expr = [\\\"DECODE({}\\\"] text_info\",\n \"IS NOT NULL ORDER BY {} DESC LIMIT {}\\\".format( self.parent.__genSQL__(),\",\n \"self.parent.__get_catalog_value__(self.alias, \\\"top\\\") if pre_comp != \\\"VERTICAPY_NOT_PRECOMPUTED\\\": if not (dropna) and\",\n \"executeSQL( query=query, title=\\\"Computing the optimized histogram nbins using Random Forest.\\\",\",\n \"expression in each record of the vColumn. vDataFrame[].str_replace : Replaces\",\n \"an optimized number of nbins will be computed. h: float,\",\n \"Also -------- vDataFrame.iv_woe : Computes the Information Value (IV) Table.\",\n \"was transformed with the func 'x -> {}'.\\\".format( self.alias.replace('\\\"', \\\"\\\"),\",\n \"= 5): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns the head of the vColumn.\",\n \"will be picked or computed) nbins: int, optional Number of\",\n \"histogram bins.\\\", method=\\\"fetchall\\\", ) result = [elem[0] for elem in\",\n \"information, see utilities.tablesample. See Also -------- vDataFrame[].tail : Returns the\",\n \"self.alias, method ) ) else: raise TypeError(\\\"The vColumn must be\",\n \"(1 / 3)] sturges : Sturges [CEIL(log2(n)) + 1] Returns\",\n \"\\\"\\\"\\\" self.parent.filter(\\\"{} IS NOT NULL\\\".format(self.alias)) return self.parent # ---# def\",\n \"False, ): \\\"\\\"\\\" --------------------------------------------------------------------------- Discretizes the vColumn using the input\",\n \"return self.apply(func=\\\"DATE_PART('{}', {})\\\".format(field, \\\"{}\\\")) # ---# def decode(self, *argv): \\\"\\\"\\\"\",\n \"sauv[elem] elif elem == None: self.catalog[elem] = None elif method\",\n \"it will represent a number. Returns ------- vDataFrame self.parent See\",\n \"like. Optimized h will be computed if the parameter is\",\n \"will be drawn. ax: Matplotlib axes object, optional The axes\",\n \"an input 'quantile'. Parameters ---------- x: float A float between\",\n \"range(max_floor): self.transformations += [(\\\"{}\\\", self.ctype(), self.category())] self.transformations += final_transformation sauv\",\n \"partition. order_by: list, optional List of the vColumns to use\",\n \"str(distinct_elements[k]).replace('\\\"', \\\"_\\\") ) ) assert not (self.parent.is_colname_in(name)), NameError( f\\\"A vColumn\",\n \"* mad) minmax : Normalization using the MinMax (min and\",\n \"e, func.replace(\\\"{}\\\", \\\"x\\\"), self.alias.replace('\\\"', \\\"\\\") ) ) # ---# def\",\n \"search. Parameters ---------- val: list List of the different records.\",\n \"self.parent.__genSQL__() ), print_time_sql=False, ) except: new_column = \\\"COALESCE({}, {}({}) OVER\",\n \"the mean encoding of a response. \\\"\\\"\\\" check_types( [ (\\\"RFmodel_params\\\",\",\n \"\\\"\\\"\\\" --------------------------------------------------------------------------- Draws the range plot of the vColumn. The\",\n \"val.replace(\\\"'\\\", \\\"''\\\") if val != None: new_column = \\\"COALESCE({}, '{}')\\\".format(\\\"{}\\\",\",\n \"percentile = 0.75) AS Q3, MAX({}) AS max FROM {}\\\".format(\",\n \"+= [lp + tmp_query + rp] query = \\\"WITH vdf_table\",\n \"---# def std(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using 'std'\",\n \"The vColumn will be transformed. Parameters ---------- start: int Start\",\n \"[ (\\\"RFmodel_params\\\", RFmodel_params, [dict]), (\\\"return_enum_trans\\\", return_enum_trans, [bool]), (\\\"h\\\", h, [int,\",\n \": Evaluates a customized expression. \\\"\\\"\\\" if isinstance(func, str_sql): func\",\n \"), (\\\"plot_median\\\", plot_median, [bool]), ] ) self.parent.are_namecols_in(ts) ts = self.parent.format_colnames(ts)\",\n \"+= [ (\\\"{}\\\", self.ctype(), self.category()) ] self.parent[copy_name].transformations += [(func, ctype,\",\n \"1 - alpha], [self.alias]) .transpose() .values[self.alias] ) self.parent.filter( \\\"({} BETWEEN\",\n \"else: self.transformations += [trans] sauv = {} for elem in\",\n \"of, [str]), (\\\"max_cardinality\\\", max_cardinality, [int, float]), (\\\"h\\\", h, [int, float]),\",\n \"stddev, self.parent.__genSQL__() ), print_time_sql=False, ) except: avg, stddev = (\",\n \"self.parent.__update_catalog__(erase=True, columns=[self.alias]) self.parent.__add_to_history__( \\\"[Mean Encode]: The vColumn {} was transformed\",\n \"vColumn_025) / (count) ** (1.0 / 3.0), 1e-99) if method.lower()\",\n \"part of the DB version you are using. Returns -------\",\n \"average See Also -------- vDataFrame.aggregate : Computes the vDataFrame input\",\n \"aggregations. \\\"\\\"\\\" return self.aggregate([\\\"max\\\"]).values[self.alias][0] # ---# def mean_encode(self, response: str):\",\n \"vDataFrame self.parent See Also -------- vDataFrame.eval : Evaluates a customized\",\n \"\\\"\\\"\\\" check_types([(\\\"add_history\\\", add_history, [bool])]) try: parent = self.parent force_columns =\",\n \"\\\"mean\\\", \\\"std\\\", \\\"min\\\", \\\"approx_25%\\\", \\\"approx_50%\\\", \\\"approx_75%\\\", \\\"max\\\", ] if method\",\n \"Also -------- vDataFrame[].str_count : Computes the number of matches for\",\n \"NULL\\\".format(self.alias) if (dropna) else \\\"\\\" query = \\\"SELECT {} AS\",\n \"DB type. Returns ------- str vColumn DB type. \\\"\\\"\\\" return\",\n \"self.parent.format_colnames(by) columns = [self.alias, by] else: columns = [self.alias] if\",\n \"minimum See Also -------- vDataFrame.aggregate : Computes the vDataFrame input\",\n \"a maximum depth of 10. response: str, optional Response vColumn\",\n \"model.set_params(RFmodel_params) parameters = model.get_params() try: model.fit(tmp_view_name, [self.alias], response) query =\",\n \"dtype : vColumn type iqr : interquartile range kurtosis :\",\n \"= self.category(), self.ctype() copy_trans = [elem for elem in self.transformations]\",\n \"conj)) self.parent.__add_to_history__( \\\"[Fillna]: {} {} missing value{} filled.\\\".format( total, self.alias,\",\n \"_verticapy_cnt_ FROM {}{}GROUP BY {} ORDER BY _verticapy_cnt_ DESC LIMIT\",\n \"data science life cycle, uses a ‘pipeline’ mechanism to sequentialize\",\n \"[self.alias, self.ctype()] + result, } if ((is_date) and not (method\",\n \"to the input vColumn. \\\"\\\"\\\" check_types([(\\\"x\\\", x, [int, float])]) assert\",\n \"import ( RandomForestClassifier, RandomForestRegressor, ) drop(tmp_model_name, method=\\\"model\\\") if self.parent[response].category() ==\",\n \"= 4.0, use_threshold: bool = True, alpha: float = 0.05\",\n \"self.parent See Also -------- vDataFrame.eval : Evaluates a customized expression.\",\n \"must be composed of two flower brackets {}. For example\",\n \"\\\"int\\\": h = int(max(math.floor(h), 1)) floor_end = -1 if (self.category()\",\n \"= to_tablesample(query, title=title).values elif ( ((distinct_count < max_cardinality + 1)\",\n \"computed. nbins: int, optional Number of bins used for the\",\n \"`\\\\ / / # | \\\\/ / / / #\",\n \"options. # # VerticaPy aims to do all of the\",\n \"range(len(result)): if result[i][2] == None: pass elif math.isnan(result[i][2]): result[i][2] =\",\n \"vColumn element.\\\", method=\\\"fetchfirstelem\\\", ) else: return getattr(self, index) # ---#\",\n \"True): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns the k most occurent elements and\",\n \"two arguments (example, power or mod), 'x' represents the second\",\n \"Union[str, datetime.datetime, datetime.date] = \\\"\\\", end_date: Union[str, datetime.datetime, datetime.date] =\",\n \"will memorize the already computed aggregations to gain in performance.\",\n \"and not (method == \\\"categorical\\\"): result = self.aggregate([\\\"count\\\", \\\"min\\\", \\\"max\\\"])\",\n \"outliers in the vColumn. vDataFrame.outliers : Adds a new vColumn\",\n \"by the different vColumn categories. Parameters ---------- response: str Response\",\n \"{} WHEN {} > {} THEN {} ELSE {} END)\\\".format(\",\n \"(\\\"kernel\\\", kernel, [\\\"gaussian\\\", \\\"logistic\\\", \\\"sigmoid\\\", \\\"silverman\\\"]), (\\\"bandwidth\\\", bandwidth, [int, float]),\",\n \"return self.quantile(0.5, approx=approx) # ---# def memory_usage(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns\",\n \"the min sem : standard error of the mean skewness\",\n \"head of the vColumn. \\\"\\\"\\\" return self.iloc(limit=limit, offset=-1) # ---#\",\n \"val = {self.alias: val} return self.parent.isin(val) # ---# def isnum(self):\",\n \": minimum mode : most occurent element percent : percent\",\n \"has two arguments (example, power or mod), 'x' represents the\",\n \"utilities.tablesample. See Also -------- vDataFrame[].tail : Returns the a part\",\n \"Equal Frequency discretization\\\" ) total, query, nth_elems = nb, [],\",\n \"= \\\"DECODE({}, {}, NULL)\\\".format( by[0], \\\", \\\".join( [ \\\"{}, {}\\\".format(\",\n \"Also -------- vDataFrame[].nsmallest : Returns the n smallest elements in\",\n \"elem == None: self.catalog[elem] = None elif method == \\\"robust_zscore\\\":\",\n \"1.01 / nbins if h > 0.01: h = round(h,\",\n \"vColumn will be considered as categorical. numcol: str, optional Numerical\",\n \"try: parent = self.parent force_columns = [ column for column\",\n \"range(len(distinct_elements)): expr += [ \\\"'{}', {}\\\".format(str(distinct_elements[k]).replace(\\\"'\\\", \\\"''\\\"), k) ] text_info\",\n \"when using TS methods. Returns ------- vDataFrame self.parent See Also\",\n \"bandwidth=bandwidth, kernel=kernel, nbins=nbins, xlim=xlim_tmp, store=False, ) try: result = model.fit(self.parent.__genSQL__(),\",\n \"= executeSQL( query=query, title=\\\"Computing the optimized histogram nbins using Random\",\n \"else: return getattr(self, index) # ---# def __len__(self): return int(self.count())\",\n \"of the vColumn. Parameters ---------- by: str, optional vColumn to\",\n \"2) elif h > 0.0001: h = round(h, 4) elif\",\n \"= ( \\\"WHEN {} < {} THEN {} \\\".format(\\\"{}\\\", lower,\",\n \"boxplot return boxplot(self, by, h, max_cardinality, cat_priority, ax=ax, **style_kwds) #\",\n \"occurent elements, how often they occur, and other statistical information.\",\n \"{} END)\\\".format( \\\"{}\\\", p_alpha, mean_alpha, \\\"{}\\\", p_1_alpha, mean_1_alpha, \\\"{}\\\" )\",\n \"self.transformations += [ ( \\\"{}::{}\\\".format(\\\"{}\\\", dtype), dtype, get_category_from_vertica_type(ctype=dtype), ) ]\",\n \"== \\\"int\\\": best_h = max(math.floor(best_h), 1) return best_h # ---#\",\n \"mad *= 1.4826 if mad != 0: if return_trans: return\",\n \"DESC LIMIT {}) VERTICAPY_SUBTABLE ORDER BY _verticapy_cnt_ ASC LIMIT 1\\\".format(\",\n \"drop_first, [bool]), (\\\"use_numbers_as_suffix\\\", use_numbers_as_suffix, [bool]), ] ) distinct_elements = self.distinct()\",\n \"p_1_alpha, \\\"{}\\\" ) ) elif method == \\\"mean\\\": query =\",\n \"if the vColumn category is date. vDataFrame[].isnum : Returns True\",\n \") method = method.lower() self.parent.are_namecols_in([elem for elem in order_by] +\",\n \"# ---# def geo_plot(self, *args, **kwargs): \\\"\\\"\\\" --------------------------------------------------------------------------- Draws the\",\n \"self.alias, p_1_alpha, ) mean_alpha, mean_1_alpha = [ item[0] for item\",\n \"/ DOY / EPOCH / HOUR / ISODOW / ISOWEEK\",\n \"vDataFrame.aggregate : Computes the vDataFrame input aggregations. \\\"\\\"\\\" check_types([(\\\"x\\\", x,\",\n \"self.parent See Also -------- vDataFrame[].str_count : Computes the number of\",\n \") self.parent.are_namecols_in(ts) ts = self.parent.format_colnames(ts) from verticapy.plot import range_curve_vdf return\",\n \"if method == \\\"winsorize\\\": self.clip(lower=p_alpha, upper=p_1_alpha) elif method == \\\"null\\\":\",\n \"FROM ({}) x\\\".format( self.alias, query, ) query = \\\"SELECT {}\",\n \"the slicing instead of the ceiling. Returns ------- vDataFrame self.parent\",\n \"ALL \\\".join(query) ) title = \\\"Describes the statics of {}\",\n \"a specific TS field from the vColumn. \\\"\\\"\\\" check_types( [\",\n \"False, ): \\\"\\\"\\\" --------------------------------------------------------------------------- Encodes the vColumn with the One-Hot\",\n \"self.parent._VERTICAPY_VARIABLES_[\\\"columns\\\"] ] force_columns.remove(self.alias) executeSQL( \\\"SELECT * FROM {} LIMIT 10\\\".format(\",\n \"\\\"{}\\\", str(distinct_elements[k]).replace(\\\"'\\\", \\\"''\\\") ) transformations = self.transformations + [(expr, \\\"bool\\\",\",\n \"mechanism to sequentialize # data transformation operations, and offers beautiful\",\n \"\\\"Others\\\", RFmodel_params: dict = {}, response: str = \\\"\\\", return_enum_trans:\",\n \"--------------------------------------------------------------------------- Divides the vColumn by the input element. Parameters ----------\",\n \"0.0001: h = round(h, 4) elif h > 0.000001: h\",\n \"ISODOW / ISOWEEK / ISOYEAR / MICROSECONDS / MILLENNIUM /\",\n \") func = \\\"(CASE {}{}ELSE {} END)\\\".format(lower_when, upper_when, \\\"{}\\\") self.apply(func=func)\",\n \"return self.parent[columns].to_geopandas(self.alias).plot(*args, **kwargs) # ---# def get_dummies( self, prefix: str\",\n \"False, ax=None, **style_kwds, ): \\\"\\\"\\\" --------------------------------------------------------------------------- Draws the range plot\",\n \"= ( \\\"AVG({}) OVER (PARTITION BY {})\\\".format( self.alias, \\\", \\\".join(by)\",\n \"(\\\"offset\\\", offset, [int, float])]) if offset < 0: offset =\",\n \"\\\"<\\\", \\\"<=\\\", \\\"]\\\", \\\"]\\\" else: op1, op2, close_l, close_r =\",\n \"quantile(alpha) or greater than quantile(1-alpha) will be dropped. Returns -------\",\n \"+= [trans] sauv = {} for elem in self.catalog: sauv[elem]\",\n \"|(_(_|| \\\\/ # / # VerticaPy is a Python library\",\n \"square root tan : trigonometric tangent tanh : hyperbolic tangent\",\n \", 'categorical' otherwise. categorical : Uses only categorical aggregations during\",\n \"NOT NULL GROUP BY 1 ORDER BY 2 DESC LIMIT\",\n \"if it is used to compute other vColumns. Parameters ----------\",\n \"to '{}'\\\".format( e, func.replace(\\\"{}\\\", \\\"x\\\"), self.alias.replace('\\\"', \\\"\\\") ) ) #\",\n \"previously the method on the vColumn \\\" \\\"or simply because\",\n \"of the vColumn. One vDataFrame can have multiple children vColumns\",\n \"Unless required by applicable law or agreed to in writing,\",\n \"vColumns are numerical. Optimized h will be computed if the\",\n \"the vColumn descriptive statistics. \\\"\\\"\\\" check_types([(\\\"k\\\", k, [int, float]), (\\\"dropna\\\",\",\n \"of the dummies ({name}).\\\\n\\\" \\\"It can be the result of\",\n \"AS {} FROM {}\\\".format( trans, self.alias, self.alias, y, y, self.parent.__genSQL__(),\",\n \"p_alpha, p_1_alpha = executeSQL( query=query, title=\\\"Computing the quantiles of {}.\\\".format(self.alias),\",\n \"of pre-computed aggregations. parent, vDataFrame : Parent of the vColumn.\",\n \"the vDataFrame.\\\".format(self.alias) ) return parent # ---# def drop_outliers( self,\",\n \"aggregations. \\\"\\\"\\\" check_types([(\\\"approx\\\", approx, [bool])]) if approx: return self.aggregate(func=[\\\"approx_unique\\\"]).values[self.alias][0] else:\",\n \"element (Constant Interpolation). ffill : Propagation of the first element\",\n \"= \\\"\\\", start_date: Union[str, datetime.datetime, datetime.date] = \\\"\\\", end_date: Union[str,\",\n \"/ # VerticaPy is a Python library with scikit-like functionality\",\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 \"Badr and Fouad are in the vColumn. You can write\",\n \"-------- vDataFrame.expected_store_usage : Returns the vDataFrame expected store usage. \\\"\\\"\\\"\",\n \"((distinct_count < max_cardinality + 1) and (method != \\\"numerical\\\")) or\",\n \"input aggregations. \\\"\\\"\\\" return self.aggregate([\\\"aad\\\"]).values[self.alias][0] # ---# def abs(self): \\\"\\\"\\\"\",\n \"with One-Hot Encoding. \\\"\\\"\\\" check_types([(\\\"response\\\", response, [str])]) self.parent.are_namecols_in(response) response =\",\n \"'x -> {}'.\\\".format( self.alias.replace('\\\"', \\\"\\\"), func.replace(\\\"{}\\\", \\\"x\\\"), ) ) return\",\n \"If set to True, the method will return the transformation\",\n \"odd : CASE ... WHEN vColumn = argv[2 * i]\",\n \"set to True, the record will be sliced using the\",\n \"if limit <= 0: limit = 0 limit = \\\"\",\n \"to transform the vColumn. The function variable must be composed\",\n \"\\\"{}\\\", to_replace.replace(\\\"'\\\", \\\"''\\\"), value.replace(\\\"'\\\", \\\"''\\\") ) ) # ---# def\",\n \"min, max, median, unique... depending on the input method. Parameters\",\n \"if (quote_ident(column) in func) or ( re.search( re.compile(\\\"\\\\\\\\b{}\\\\\\\\b\\\".format(column.replace('\\\"', \\\"\\\"))), func\",\n \"------- vDataFrame self.parent See Also -------- vDataFrame.apply : Applies functions\",\n \"import spider as spider_plot return spider_plot( self.parent, columns, method, of,\",\n \"in case of discretization using the method 'topk'\\\" ) distinct\",\n \"The less frequent elements will be gathered together to create\",\n \"and self.nunique(True) > 6) else \\\"mode\\\" total = self.count() if\",\n \"/ # |______ / / / # |____/ / /\",\n \"vDataFrame[].isbool : Returns True if the vColumn is boolean. vDataFrame[].isnum\",\n \"{} < {}\\\".format( self.alias, result[\\\"avg\\\"][0], result[\\\"std\\\"][0], threshold ) ) else:\",\n \"-------- vDataFrame[].slice : Slices the vColumn using a time series\",\n \"verticapy.plot import range_curve_vdf return range_curve_vdf( self, ts, q, start_date, end_date,\",\n \") title = \\\"Describes the statics of {} partitioned by\",\n \"specific records are in the vColumn and it returns the\",\n \"... END odd : CASE ... WHEN vColumn = argv[2\",\n \"in range(1, n): trans += \\\"WHEN {} BETWEEN {} AND\",\n \"the 'topk' method. RFmodel_params: dict, optional Dictionary of the Random\",\n \"element density unique : cardinality (count distinct) var : variance\",\n \"more information, see: https://geopandas.readthedocs.io/en/latest/docs/reference/api/ geopandas.GeoDataFrame.plot.html Returns ------- ax Matplotlib axes\",\n \"model.drop() return result except: model.drop() raise # ---# def describe(\",\n \"the vColumn. The aggregations used are the median and two\",\n \"'of'. min : Minimum of the vColumn 'of'. max :\",\n \"self.alias, self.parent.__genSQL__(), self.alias ) executeSQL(query, title=\\\"Testing the Type casting.\\\") self.transformations\",\n \"isinstance(val, str) or not (isinstance(val, Iterable)): val = [val] val\",\n \"[int, float])]) if offset < 0: offset = max(0, self.parent.shape()[0]\",\n \"vColumn is null, 1 otherwise. expr: str, optional SQL expression.\",\n \"dict : Catalog of pre-computed aggregations. parent, vDataFrame : Parent\",\n \"self.alias, self.alias, self.alias, table ) result = executeSQL( query, title=\\\"Different\",\n \"method != \\\"cat_stats\\\": values = { \\\"index\\\": [\\\"name\\\", \\\"dtype\\\"] +\",\n \"the vColumn based on an aggregation. \\\"\\\"\\\" check_types( [ (\\\"by\\\",\",\n \"an optimized number of bins will be computed. h: float,\",\n \"use iv_woe.\\\".format(y) ) response_cat = self.parent[y].distinct() response_cat.sort() assert response_cat ==\",\n \"and method == \\\"same_freq\\\": assert nbins >= 2, ParameterError( \\\"Parameter\",\n \"= \\\"Reads {} {} largest elements.\\\".format(self.alias, n) return to_tablesample(query, title=title)\",\n \"\\\"minmax\\\"]), (\\\"by\\\", by, [list]), (\\\"return_trans\\\", return_trans, [bool]), ] ) method\",\n \"float kurtosis See Also -------- vDataFrame.aggregate : Computes the vDataFrame\",\n \"x, [int, float])]) if self.isdate(): return self.apply(func=\\\"TIMESTAMPADD(SECOND, -({}), {})\\\".format(x, \\\"{}\\\"))\",\n \"str): by = [by] if isinstance(order_by, str): order_by = [order_by]\",\n \"\\\"max\\\": 1, \\\"count\\\": self.parent.shape()[0], \\\"percent\\\": 100.0, \\\"unique\\\": 2, \\\"approx_unique\\\": 2,\",\n \"+ 5). ax: Matplotlib axes object, optional The axes to\",\n \"cmin, \\\"NULLIFZERO\\\" if (nullifzero) else \\\"\\\", cmax, cmin, ) else:\",\n \"bin_spatial_to_str(self.category(), self.alias), self.alias, self.parent.shape()[0], self.parent.__genSQL__(), dropna, self.alias, topk, ) result\",\n \"# data transformation operations, and offers beautiful graphical options. #\",\n \"= \\\"second\\\", start: bool = True): \\\"\\\"\\\" --------------------------------------------------------------------------- Slices and\",\n \"total, self.alias, conj, ) ) else: if verticapy.options[\\\"print_info\\\"]: print(\\\"Nothing was\",\n \"\\\"\\\"\\\" if isinstance(by, str): by = [by] check_types( [ (\\\"method\\\",\",\n \"return getattr(self, index) # ---# def __len__(self): return int(self.count()) #\",\n \"), ) executeSQL( \\\"SELECT {}, {} FROM {} LIMIT 1\\\".format(\",\n \"mean). Returns ------- float sem See Also -------- vDataFrame.aggregate :\",\n \"{}{} OFFSET {} LIMIT 1\\\".format( self.alias, cast, self.parent.__genSQL__(), self.parent.__get_last_order_by__(), index,\",\n \"return self.aggregate([\\\"sum\\\"]).values[self.alias][0] # ---# def tail(self, limit: int = 5):\",\n \"method=\\\"fetchall\\\", ) result = [distinct_count, self.count()] + [item[1] for item\",\n \"------- vDataFrame self.parent See Also -------- vDataFrame.eval : Evaluates a\",\n \"use to order the data\\\" ) desc = \\\"\\\" if\",\n \"def decode(self, *argv): \\\"\\\"\\\" --------------------------------------------------------------------------- Encodes the vColumn using a\",\n \") except: ctype = get_data_types( \\\"SELECT {} AS apply_test_feature FROM\",\n \"corresponds to an aggregation. vColumns will memorize the already computed\",\n \"Number of bins used for the discretization (must be >\",\n \"order_by] + by) by = self.parent.format_colnames(by) if method == \\\"auto\\\":\",\n \"check_types([(\\\"start\\\", start, [int, float]), (\\\"step\\\", step, [int, float])]) return self.apply(func=\\\"SUBSTR({},\",\n \"self.ctype()] + result, } if ((is_date) and not (method ==\",\n \") for i in range(parameters[\\\"n_estimators\\\"]) ] query = \\\"SELECT split_value\",\n \"by, [str]), (\\\"kernel\\\", kernel, [\\\"gaussian\\\", \\\"logistic\\\", \\\"sigmoid\\\", \\\"silverman\\\"]), (\\\"bandwidth\\\", bandwidth,\",\n \"Uses only categorical aggregations during the computation. cat_stats : Computes\",\n \"method: str, optional The describe method. auto : Sets the\",\n \"date_part(self, field: str): \\\"\\\"\\\" --------------------------------------------------------------------------- Extracts a specific TS field\",\n \"* (int(sauv[\\\"count\\\"]) + total) / self.parent.shape()[0] ) except: pass total\",\n \"else \\\"NULL\\\", elem[1] if elem[1] != None else \\\"NULL\\\", )\",\n \"filled. Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].drop_outliers :\",\n \"the vColumn is numerical. See Also -------- vDataFrame[].isbool : Returns\",\n \"self.transformations ) for k in range(max_floor): self.transformations += [(\\\"{}\\\", self.ctype(),\",\n \"query, ) query = \\\"SELECT {} AS index, non_events, events,\",\n \"result = executeSQL( query, title=\\\"Computing the top{} categories of {}.\\\".format(\",\n \"with scikit-like functionality for conducting # data science projects on\",\n \"title = \\\"Reads {} {} smallest elements.\\\".format(n, self.alias) return to_tablesample(query,\",\n \"to solve this issue.\\\" ) new_vColumn = vColumn( name, parent=self.parent,\",\n \"if isinstance(order_by, str): order_by = [order_by] check_types( [ ( \\\"method\\\",\",\n \"category is date. See Also -------- vDataFrame[].isbool : Returns True\",\n \"discretization (must be > 1) Returns ------- tablesample An object\",\n \"len(cat) == 1: lp, rp = \\\"(\\\", \\\")\\\" else: lp,\",\n \"return self mad, med = self.aggregate([\\\"mad\\\", \\\"approx_median\\\"]).values[self.alias] mad *= 1.4826\",\n \"/ # \\\\ / # \\\\ / # \\\\/ #\",\n \") return self.parent # ---# def distinct(self, **kwargs): \\\"\\\"\\\" ---------------------------------------------------------------------------\",\n \"{}({}) FROM {} GROUP BY {};\\\".format( by[0], fun, self.alias, self.parent.__genSQL__(),\",\n \"input aggregations. \\\"\\\"\\\" return self.aggregate([\\\"sem\\\"]).values[self.alias][0] # ---# def skewness(self): \\\"\\\"\\\"\",\n \"return spider_plot( self.parent, columns, method, of, max_cardinality, h, ax=ax, **style_kwds,\",\n \"x)) # ---# def nlargest(self, n: int = 10): \\\"\\\"\\\"\",\n \"sys.getsizeof(elem) return total # ---# def min(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates\",\n \"must be empty.\\\" ) conditions, column = [], self.alias for\",\n \"[], ): \\\"\\\"\\\" --------------------------------------------------------------------------- Fills missing elements in the vColumn\",\n \"DESC\\\".format( self.alias, bin_spatial_to_str(self.category(), self.alias), self.alias, kwargs[\\\"agg\\\"], self.parent.__genSQL__(), self.alias, ) query_result\",\n \"\\\" ELSE NULL END)\\\" trans = (trans, \\\"varchar\\\", \\\"text\\\") if\",\n \"vColumn using 'count' (Number of non-Missing elements). Returns ------- int\",\n \"str = \\\"\\\", h: float = 0, max_cardinality: int =\",\n \"= \\\"\\\" if (n == 1) else str(int(n)) if isinstance(top,\",\n \"to 0, an optimised interval will be computed. nbins: int,\",\n \"return_trans: return \\\"({} - {}) / {}({})\\\".format( self.alias, avg, \\\"NULLIFZERO\\\"\",\n \"func.replace(\\\"{}\\\", \\\"x\\\"), self.alias.replace('\\\"', \\\"\\\") ) ) # ---# def apply_fun(self,\",\n \"\\\"\\\", max_cardinality: int = 6, nbins: int = 0, h:\",\n \"( method == \\\"is_numeric\\\" ): self.parent.__update_catalog__({\\\"index\\\": index, self.alias: result}) for\",\n \"you'll be able to solve this \\\" \\\"issue.\\\" ) for\",\n \"close_r = \\\"<\\\", \\\"<=\\\", \\\"]\\\", \\\"]\\\" else: op1, op2, close_l,\",\n \"Returns the a part of the vColumn. \\\"\\\"\\\" return self.iloc(limit=limit)\",\n \": Slices the vColumn. \\\"\\\"\\\" check_types([(\\\"pat\\\", pat, [str])]) return self.apply(\",\n \"def str_slice(self, start: int, step: int): \\\"\\\"\\\" --------------------------------------------------------------------------- Slices the\",\n \"by, [str]), (\\\"max_cardinality\\\", max_cardinality, [int, float]), (\\\"h\\\", h, [int, float]),\",\n \"# ---# def plot( self, ts: str, by: str =\",\n \"type. \\\"\\\"\\\" check_types([(\\\"dtype\\\", dtype, [str])]) try: query = \\\"SELECT {}::{}\",\n \"if return_enum_trans: return trans else: self.transformations += [trans] sauv =\",\n \"ELSE {} END)\\\".format( \\\"{}\\\", p_alpha, mean_alpha, \\\"{}\\\", p_1_alpha, mean_1_alpha, \\\"{}\\\"\",\n \"ZONE / TIMEZONE_HOUR / TIMEZONE_MINUTE / WEEK / YEAR Returns\",\n \"= ( self.parent.quantile([alpha, 1 - alpha], [self.alias]) .transpose() .values[self.alias] )\",\n \"plot_median: bool = False, ax=None, **style_kwds, ): \\\"\\\"\\\" --------------------------------------------------------------------------- Draws\",\n \"the vColumn based on an aggregation. Parameters ---------- method: str,\",\n \"the vColumn. abs : absolute value acos : trigonometric inverse\",\n \"text_info = \\\"\\\\n\\\" for k in range(len(distinct_elements)): expr += [\",\n \"[distinct_count] + result index = [ \\\"unique\\\", \\\"count\\\", \\\"mean\\\", \\\"std\\\",\",\n \"and lower outliers by their respective average. null : Replaces\",\n \"= True if pie_type == \\\"donut\\\" else False rose =\",\n \"else the lower and upper ZScores. threshold: float, optional Uses\",\n \"pat: str Regular expression. Returns ------- vDataFrame self.parent See Also\",\n \"new_category: str, optional The name of the merging category when\",\n \"in self.transformations], catalog=self.catalog, ) setattr(self.parent, name, new_vColumn) setattr(self.parent, name[1:-1], new_vColumn)\",\n \"( self.parent.quantile([alpha, 1 - alpha], [self.alias]) .transpose() .values[self.alias] ) self.parent.filter(\",\n \"input vColumns from the vDataFrame. \\\"\\\"\\\" check_types([(\\\"add_history\\\", add_history, [bool])]) try:\",\n \": Sets the method to 'numerical' if the vColumn is\",\n \"assert x != 0, ValueError(\\\"Division by 0 is forbidden !\\\")\",\n \"rp = \\\"(\\\", \\\")\\\" else: lp, rp = \\\"\\\", \\\"\\\"\",\n \"= self.parent.format_colnames(of) from verticapy.plot import pie return pie( self, method,\",\n \"vDataFrame.iv_woe : Computes the Information Value (IV) Table. \\\"\\\"\\\" check_types([(\\\"y\\\",\",\n \"default function to the vColumn. Parameters ---------- func: str Function\",\n \"100.0, \\\"unique\\\": 2, \\\"approx_unique\\\": 2, \\\"prod\\\": 0, }, ) setattr(self.parent,\",\n \"You may obtain a copy of the License at #\",\n \"[str]), (\\\"max_cardinality\\\", max_cardinality, [int, float]), (\\\"nbins\\\", nbins, [int, float]), (\\\"h\\\",\",\n \"[elem for elem in copy_trans] raise QueryError(\\\"{}\\\\nAn Error happened during\",\n \"alpha, self.alias, alpha, self.alias, self.parent.__genSQL__() ) p_alpha, p_1_alpha = executeSQL(\",\n \"= executeSQL( query, title=\\\"Different aggregations to compute the optimal h.\\\",\",\n \"mode of the vColumn. Returns ------- str/float/int vColumn nth most\",\n \"return the transformation used instead of the parent vDataFrame. This\",\n \"quote_ident(self.alias) new_name = new_name.replace('\\\"', \\\"\\\") assert not (self.parent.is_colname_in(new_name)), NameError( f\\\"A\",\n \"len(self.parent[column].transformations), max_floor ) except: pass max_floor -= len(self.transformations) if copy_name:\",\n \"__init__( self, alias: str, transformations: list = [], parent=None, catalog:\",\n \") result = [distinct_count] + result index = [ \\\"unique\\\",\",\n \"Special Methods # # ---# def __init__( self, alias: str,\",\n \"q% : q quantile (ex: 50% for the median) prod\",\n \"Also -------- vDataFrame.fill_outliers : Fills the outliers in the vColumn.\",\n \"= \\\"\\\\n\\\" for k in range(len(distinct_elements)): expr += [ \\\"'{}',\",\n \"n: int Number of digits to keep after the comma.\",\n \"numerical (except ints and bools), a RF Classifier otherwise. Example:\",\n \"force_columns = [ column for column in self.parent._VERTICAPY_VARIABLES_[\\\"columns\\\"] ] force_columns.remove(self.alias)\",\n \"= 0.05 ): \\\"\\\"\\\" --------------------------------------------------------------------------- Drops outliers in the vColumn.\",\n \"--------------------------------------------------------------------------- Returns the nth most occurent element. Parameters ---------- dropna:\",\n \"the data when 'ts' is greater than November 1993 the\",\n \"to apply the function: x -> x^2 + 2 use\",\n \"parameter is empty or invalid. max_cardinality: int, optional Maximum number\",\n \"value acos : trigonometric inverse cosine asin : trigonometric inverse\",\n \"the top{} categories of {}.\\\".format( k if k > 0\",\n \"[int, float]), (\\\"h\\\", h, [int, float]), (\\\"pie_type\\\", pie_type, [\\\"auto\\\", \\\"donut\\\",\",\n \"distribution to identify outliers. After normalizing the data (Z-Score), if\",\n \"\\\"ffill\\\", \\\"pad\\\", \\\"bfill\\\", \\\"backfill\\\", ], ), (\\\"expr\\\", expr, [str]), (\\\"by\\\",\",\n \"self.parent.shape()[0] tail.offset = offset tail.dtype[self.alias] = self.ctype() tail.name = self.alias\",\n \"plot of the input vColumn based on an aggregation. Parameters\",\n \"WHERE {0} IS NOT NULL GROUP BY {0} ORDER BY\",\n \": Draws the Box Plot of the input vColumns. \\\"\\\"\\\"\",\n \"Upper bound. Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].fill_outliers\",\n \"int, optional Number of most occurent elements to return. dropna:\",\n \"ROW_NUMBER() OVER (ORDER BY {}) AS _verticapy_row_nb_ FROM {} WHERE\",\n \"= gen_tmp_name(schema=schema, name=\\\"model\\\") assert nbins >= 2, ParameterError( \\\"Parameter 'nbins'\",\n \"0 THEN 0 ELSE ZEROIFNULL(LN(pt_non_events / NULLIFZERO(pt_events))) END AS woe,\",\n \"the outliers. After normalizing the data (Z-Score), if the absolute\",\n \"func=\\\"REGEXP_SUBSTR({}, '{}')\\\".format(\\\"{}\\\", pat.replace(\\\"'\\\", \\\"''\\\")) ) # ---# def str_replace(self, to_replace:\",\n \"== None): val = self.mode(dropna=True) if val == None: warning_message\",\n \"MIN and the MAX. MAX = MIN !\\\".format( self.alias )\",\n \"will be transformed. Parameters ---------- to_replace: str Regular expression to\",\n \"OVER (PARTITION BY {})\\\".format( self.alias, \\\", \\\".join(by) ), \\\"MIN({}) OVER\",\n \"(\\\"by\\\", by, [list]), (\\\"return_trans\\\", return_trans, [bool]), ] ) method =\",\n \"NULL GROUP BY {0} ORDER BY COUNT(*)\\\" \\\" DESC OFFSET\",\n \"valid if the vColumns are numerical. Optimized h will be\",\n \"self.apply( func=\\\"REGEXP_COUNT({}, '{}') > 0\\\".format(\\\"{}\\\", pat.replace(\\\"'\\\", \\\"''\\\")) ) # ---#\",\n \"of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless\",\n \"vColumn record by an input value. The vColumn will be\",\n \"x: float): \\\"\\\"\\\" --------------------------------------------------------------------------- Subtracts the input element from the\",\n \"is in each of the vColumn records. vDataFrame[].extract : Extracts\",\n \"fd) self.parent.__update_catalog__({\\\"index\\\": [\\\"numh\\\"], self.alias: [best_h]}) if self.category() == \\\"int\\\": best_h\",\n \"method.lower() in (\\\"freedman_diaconis\\\", \\\"fd\\\"): best_h = fd else: best_h =\",\n \"method: str = \\\"density\\\", of: str = \\\"\\\", max_cardinality: Union[int,\",\n \"[ (\\\"method\\\", method, [\\\"auto\\\", \\\"numerical\\\", \\\"categorical\\\", \\\"cat_stats\\\"]), (\\\"max_cardinality\\\", max_cardinality, [int,\",\n \"self.catalog[\\\"percent\\\"] = ( 100 * sauv[\\\"count\\\"] / self.parent.shape()[0] ) except:\",\n \"\\\"\\\"\\\" return self.aggregate([\\\"count\\\"]).values[self.alias][0] # ---# def cut( self, breaks: list,\",\n \"= \\\"SELECT * FROM {} WHERE {} IS NOT NULL\",\n \"like (date, datetime, timestamp...) or numerical. by: str, optional vColumn\",\n \"self.iloc(limit=limit) # ---# def hist( self, method: str = \\\"density\\\",\",\n \"x: float, approx: bool = True): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the\",\n \"= \\\"SELECT {} AS {}, COUNT(*) AS _verticapy_cnt_, 100 *\",\n \"astype(self, dtype: str): \\\"\\\"\\\" --------------------------------------------------------------------------- Converts the vColumn to the\",\n \"also be a cutomized aggregation (ex: AVG(column1) + 5). ax:\",\n \"# ---# def value_counts(self, k: int = 30): \\\"\\\"\\\" ---------------------------------------------------------------------------\",\n \"if right: op1, op2, close_l, close_r = \\\"<\\\", \\\"<=\\\", \\\"]\\\",\",\n \"labeled with 0 and 1 (1 meaning global outlier). \\\"\\\"\\\"\",\n \"result = model.fit(self.parent.__genSQL__(), [self.alias]).plot( ax=ax, **style_kwds ) model.drop() return result\",\n \"the intervals will be closed on the right. Returns -------\",\n \"This parameter is very useful for testing to be able\",\n \"= \\\"SELECT PERCENTILE_CONT({}) WITHIN GROUP (ORDER BY {}) OVER (),\",\n \"\\\"bfill\\\", \\\"backfill\\\"]: all_partition += [elem for elem in order_by] for\",\n \"(14, 10) return self.parent[columns].to_geopandas(self.alias).plot(*args, **kwargs) # ---# def get_dummies( self,\",\n \"area, [bool]), (\\\"step\\\", step, [bool]), ] ) self.parent.are_namecols_in(ts) ts =\",\n \"one column of that relation. vColumns simplify several processes with\",\n \"# \\\\ / / / # \\\\_______/ / / #\",\n \"bar width. Parameters ---------- method: str, optional Method to use\",\n \"optional The method to use to discretize the vColumn. auto\",\n \"the parameter 'by' is empty\\\\nIf you want to normalize by\",\n \"numh(self, method: str = \\\"auto\\\"): \\\"\\\"\\\" --------------------------------------------------------------------------- Computes the optimal\",\n \"{}\\\".format( self.alias, result[\\\"avg\\\"][0], result[\\\"std\\\"][0], threshold ) ) else: p_alpha, p_1_alpha\",\n \"return self.parent if isinstance(val, str): val = val.replace(\\\"'\\\", \\\"''\\\") if\",\n \"vdf_table WHERE {} > {})\\\".format( self.parent.__genSQL__(), self.alias, self.alias, p_alpha, self.alias,\",\n \"in range(len(result)): if result[i][2] == None: pass elif math.isnan(result[i][2]): result[i][2]\",\n \"100 * sauv[\\\"count\\\"] / self.parent.shape()[0] ) for elem in sauv:\",\n \"[], return_trans: bool = False ): \\\"\\\"\\\" --------------------------------------------------------------------------- Normalizes the\",\n \"method, [ \\\"auto\\\", \\\"mode\\\", \\\"0ifnull\\\", \\\"mean\\\", \\\"avg\\\", \\\"median\\\", \\\"ffill\\\", \\\"pad\\\",\",\n \"= ( \\\"'[' || FLOOR({} / {}) * {} ||\",\n \"of non-missing elements cvar : conditional value at risk dtype\",\n \"BY 1) x ORDER BY verticapy_agg DESC\\\".format( self.alias, bin_spatial_to_str(self.category(), self.alias),\",\n \"analytical function on a specific vColumn. \\\"\\\"\\\" return self.parent.aggregate(func=func, columns=[self.alias]).transpose()\",\n \"if isinstance(by, str): by = [by] if isinstance(order_by, str): order_by\",\n \"as spider_plot return spider_plot( self.parent, columns, method, of, max_cardinality, h,\",\n \"vColumn will be transformed. Parameters ---------- start: int Start of\",\n \"optional Catalog where each key corresponds to an aggregation. vColumns\",\n \") self.parent.__update_catalog__( {\\\"index\\\": [\\\"store_usage\\\"], self.alias: [store_usage]} ) return store_usage #\",\n \"not (\\\"cmap\\\" in kwargs): from verticapy.plot import gen_cmap kwargs[\\\"cmap\\\"] =\",\n \"categories of {}.\\\".format( k if k > 0 else \\\"\\\",\",\n \"... WHEN vColumn = argv[2 * i] THEN argv[2 *\",\n \"method in zscore|minmax\\\" warnings.warn(warning_message, Warning) return self mad, med =\",\n \"str): \\\"\\\"\\\" --------------------------------------------------------------------------- Adds a copy vColumn to the parent\",\n \"an aggregation. \\\"\\\"\\\" check_types( [ (\\\"method\\\", method, [str]), (\\\"of\\\", of,\",\n \"Python Modules import math, re, decimal, warnings, datetime from collections.abc\",\n \"Returns ------- int number of non-Missing elements. See Also --------\",\n \"AS {}, {} AS verticapy_agg FROM {} WHERE {} IS\",\n \": Drops outliers in the vColumn. vDataFrame.outliers : Adds a\",\n \"See Also -------- vDataFrame.donut : Draws the donut chart of\",\n \"if the vColumn will be considered as categorical. numcol: str,\",\n \"return self.aggregate([\\\"count\\\"]).values[self.alias][0] # ---# def cut( self, breaks: list, labels:\",\n \"top = None if not (result) else result[0][0] if not\",\n \"have one parent. catalog: dict, optional Catalog where each key\",\n \"(\\\"length\\\", length, [int, float]), (\\\"unit\\\", unit, [str]), (\\\"start\\\", start, [bool]),\",\n \"step: int Size of the slicing. Returns ------- vDataFrame self.parent\",\n \"/ DOQ / DOW / DOY / EPOCH / HOUR\",\n \"\\\"\\\"\\\" --------------------------------------------------------------------------- Extracts the regular expression in each record of\",\n \"columns, title=by, loc=\\\"center left\\\", bbox_to_anchor=[1, 0.5], ) ax.set_xlabel(self.alias) return ax\",\n \"in query_result] else: result = ( self.parent.describe( method=\\\"numerical\\\", columns=[self.alias], unique=False\",\n \"return pre_comp assert self.isnum() or self.isdate(), ParameterError( \\\"numh is only\",\n \"See Also -------- vDataFrame[].decode : Encodes the vColumn using a\",\n \"AS 'approx_50%', APPROXIMATE_PERCENTILE ({3}{4} USING PARAMETERS percentile = 0.75) AS\",\n \"def isdate(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns True if the vColumn category\",\n \"user defined Encoding. vDataFrame[].get_dummies : Encodes the vColumn with One-Hot\",\n \"desc = \\\"\\\" if (method in (\\\"ffill\\\", \\\"pad\\\")) else \\\"\",\n \"upper_when, \\\"{}\\\") self.apply(func=func) return self.parent # ---# def count(self): \\\"\\\"\\\"\",\n \"2 use \\\"POWER({}, 2) + 2\\\". copy_name: str, optional If\",\n \"discretization using the method 'topk'\\\" ) distinct = self.topk(k).values[\\\"index\\\"] trans\",\n \"(nullifzero) else \\\"\\\", stddev ), \\\"float\\\", \\\"float\\\", ) ] elif\",\n \"self.apply(func=expr) # ---# def ctype(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns the vColumn\",\n \"Average of the vColumn 'of'. min : Minimum of the\",\n \"the vColumn. See Also -------- vDataFrame.topk : Returns the vColumn\",\n \"optimal vColumn bar width. Parameters ---------- method: str, optional Method\",\n \"= self.mode(dropna=True) if val == None: warning_message = \\\"The vColumn\",\n \"(dropna): n = \\\"\\\" if (n == 1) else str(int(n))\",\n \"\\\"_\\\") .replace(\\\",\\\", \\\"_\\\") .replace(\\\"'\\\", \\\"_\\\") ) expr = \\\"DECODE({}, '{}',\",\n \"{} AS percent FROM {}{} GROUP BY {} ORDER BY\",\n \"on booleans\\\".format(self.alias) warnings.warn(warning_message, Warning) elif self.isnum(): if method == \\\"zscore\\\":\",\n \"Regressor will be trained if the response is numerical (except\",\n \"self.parent See Also -------- vDataFrame[].str_contains : Verifies if the regular\",\n \"range_curve_vdf( self, ts, q, start_date, end_date, plot_median, ax=ax, **style_kwds, )\",\n \"Aggregates the vColumn using 'std' (Standard Deviation). Returns ------- float\",\n \"cast = \\\"::int\\\" if (self.parent[numcol].isbool()) else \\\"\\\" query, cat =\",\n \"quantile(self, x: float, approx: bool = True): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates\",\n \"elif method == \\\"minmax\\\": self.catalog[\\\"min\\\"] = 0 self.catalog[\\\"max\\\"] = 1\",\n \"--------------------------------------------------------------------------- Draws the spider plot of the input vColumn based\",\n \"(\\\"of\\\", of, [str]), (\\\"max_cardinality\\\", max_cardinality, [int, float]), (\\\"nbins\\\", nbins, [int,\",\n \"list, optional List of the vColumns to use to sort\",\n \"Returns ------- float std See Also -------- vDataFrame.aggregate : Computes\",\n \"Returns ------- str vColumn DB type. \\\"\\\"\\\" return self.transformations[-1][1].lower() dtype\",\n \"upper=p_1_alpha) elif method == \\\"null\\\": self.apply( func=\\\"(CASE WHEN ({} BETWEEN\",\n \"Number of elements to display. Returns ------- tablesample An object\",\n \"(response = {}).\\\".format(self.alias, y) result = to_tablesample(query, title=title) result.values[\\\"index\\\"] +=\",\n \"BY {}\\\".format( by[0], self.alias, self.alias, self.parent.__genSQL__(), by[0], ), title=\\\"Computing the\",\n \"range(len(values[elem])): if isinstance(values[elem][i], decimal.Decimal): values[elem][i] = float(values[elem][i]) return tablesample(values) #\",\n \"sauv[\\\"mean\\\"]) / sauv[ \\\"std\\\" ] elif method == \\\"minmax\\\": self.catalog[elem]\",\n \"self.apply( func=\\\"REGEXP_REPLACE({}, '{}', '{}')\\\".format( \\\"{}\\\", to_replace.replace(\\\"'\\\", \\\"''\\\"), value.replace(\\\"'\\\", \\\"''\\\") )\",\n \"{1}) VERTICAPY_SUBTABLE) ORDER BY count DESC\\\" ).format(self.alias, max_cardinality + 1)\",\n \"vColumn category. See Also -------- vDataFrame[].ctype : Returns the vColumn\",\n \"upper bound itself. Parameters ---------- lower: float, optional Lower bound.\",\n \"'aad' (Average Absolute Deviation). Returns ------- float aad See Also\",\n \"Computes the Information Value (IV) Table. \\\"\\\"\\\" check_types([(\\\"y\\\", y, [str]),\",\n \"in [\\\"date\\\", \\\"float\\\"]: warning_message = ( \\\"label_encode is only available\",\n \"optional If set to True, the approximate median is returned.\",\n \"by elements, please use a method in zscore|minmax\\\" warnings.warn(warning_message, Warning)\",\n \"Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].str_count : Computes\",\n \"\\\"median\\\"): fun = \\\"MEDIAN\\\" if (method == \\\"median\\\") else \\\"AVG\\\"\",\n \"[str]), (\\\"start\\\", start, [bool]), ] ) start_or_end = \\\"START\\\" if\",\n \"cmin, self.parent.__genSQL__() ), print_time_sql=False, ) except: cmax, cmin = (\",\n \"optional Tuple including the 2 quantiles used to draw the\",\n \"method: str = \\\"auto\\\"): \\\"\\\"\\\" --------------------------------------------------------------------------- Computes the optimal vColumn\",\n \"(\\\"labels\\\", labels, [list]), (\\\"include_lowest\\\", include_lowest, [bool]), (\\\"right\\\", right, [bool]), ]\",\n \"if verticapy.options[\\\"print_info\\\"]: print(\\\"Nothing was filled.\\\") self.transformations = [elem for elem\",\n \"vDataFrame input aggregations. \\\"\\\"\\\" return self.quantile(0.5, approx=approx) # ---# def\",\n \"elem in result if elem[2] != None ] ), )\",\n \"Slices the vColumn using a time series rule. \\\"\\\"\\\" return\",\n \"= ( self.nunique(), self.isnum(), self.isdate(), ) if (is_date) and not\",\n \"\\\".format( \\\"{}\\\", result[i - 1], result[i], result[i - 1], result[i]\",\n \"method=\\\"same_width\\\" if self.isnum() else \\\"topk\\\", nbins=nbins, k=nbins, new_category=\\\"Others\\\", return_enum_trans=True, )[0].replace(\\\"{}\\\",\",\n \"item in result], \\\"count\\\": [int(item[1]) for item in result], \\\"percent\\\":\",\n \"\\\"{}\\\")) else: return self.apply(func=\\\"{} - ({})\\\".format(\\\"{}\\\", x)) # ---# def\",\n \"of the following: CENTURY / DAY / DECADE / DOQ\",\n \"= self.parent.format_colnames(by) from verticapy.plot import boxplot return boxplot(self, by, h,\",\n \"elem in result] except: drop(tmp_view_name, method=\\\"view\\\") drop(tmp_model_name, method=\\\"model\\\") raise drop(tmp_view_name,\",\n \"vDataFrame self.parent See Also -------- vDataFrame.apply : Applies functions to\",\n \"pie( self, method: str = \\\"density\\\", of: str = \\\"\\\",\",\n \"when the parent vDataFrame is modified. Attributes ---------- alias, str\",\n \"self.alias, self.alias, self.parent.__genSQL__(), self.alias, where, ) result = executeSQL( query=query,\",\n \"vColumn( name, parent=self.parent, transformations=[item for item in self.transformations], catalog=self.catalog, )\",\n \"- ({})\\\".format(\\\"{}\\\", x)) # ---# def sum(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates\",\n \"search. See Also -------- vDataFrame.isin : Looks if some specific\",\n \"optional Number of bins. If empty, an optimized number of\",\n \"information, see utilities.tablesample. See Also -------- vDataFrame[].nsmallest : Returns the\",\n \"xlim: tuple = None, ax=None, **style_kwds, ): \\\"\\\"\\\" --------------------------------------------------------------------------- Draws\",\n \"if by: self.parent.are_namecols_in(by) by = self.parent.format_colnames(by) from verticapy.plot import gen_colors\",\n \"| |(_(_|| \\\\/ # / # VerticaPy is a Python\",\n \"in all_cols: try: if (quote_ident(column) in func) or ( re.search(\",\n \"DAY / DECADE / DOQ / DOW / DOY /\",\n \"for the plot. gaussian : Gaussian kernel. logistic : Logistic\",\n \"in each record of the vColumn. vDataFrame[].str_slice : Slices the\",\n \"tail.dtype[self.alias] = self.ctype() tail.name = self.alias return tail # ---#\",\n \"{} IS NOT NULL\\\".format(self.alias) if (dropna) else \\\"\\\" query =\",\n \"str): \\\"\\\"\\\" --------------------------------------------------------------------------- Extracts a specific TS field from the\",\n \"is date. vDataFrame[].isnum : Returns True if the vColumn is\",\n \": Sigmoid kernel. silverman : Silverman kernel. nbins: int, optional\",\n \"method=\\\"fetchrow\\\", ) if method == \\\"winsorize\\\": self.clip(lower=p_alpha, upper=p_1_alpha) elif method\",\n \"floor of the slicing instead of the ceiling. Returns -------\",\n \"!\\\".format( self.alias ) warnings.warn(warning_message, Warning) return self elif n ==\",\n \"\\\"AVG\\\": val = self.avg() elif fun == \\\"MEDIAN\\\": val =\",\n \"labels: list, optional Labels used to name the new categories.\",\n \"IS NOT NULL GROUP BY 1) x ORDER BY verticapy_agg\",\n \"customized expression. \\\"\\\"\\\" check_types([(\\\"name\\\", name, [str])]) name = quote_ident(name.replace('\\\"', \\\"_\\\"))\",\n \"\\\"smart\\\", \\\"same_width\\\", \\\"same_freq\\\", \\\"topk\\\"], ), (\\\"return_enum_trans\\\", return_enum_trans, [bool]), ] )\",\n \"float): \\\"\\\"\\\" --------------------------------------------------------------------------- Multiplies the vColumn by the input element.\",\n \"= round(h, 2) elif h > 0.0001: h = round(h,\",\n \"(example, power or mod), 'x' represents the second argument. Returns\",\n \"check if Badr and Fouad are in the vColumn. You\",\n \"{column} {op2} '{second_elem}' THEN '{label}'\\\" ] expr = \\\"CASE WHEN\",\n \"cat = [], self.distinct() if len(cat) == 1: lp, rp\",\n \"--------------------------------------------------------------------------- Encodes the vColumn using a bijection from the different\",\n \"the final transformation. Returns ------- vDataFrame self.parent See Also --------\",\n \"distributed under the License is distributed on an \\\"AS IS\\\"\",\n \"self.parent.__genSQL__(), self.parent.__get_last_order_by__(), index, ) return executeSQL( query=query, title=\\\"Getting the vColumn\",\n \"optimal If set to True, the method will return the\",\n \"the mode.\\\", method=\\\"fetchall\\\", ) top = None if not (result)\",\n \"Returns ------- float/str maximum See Also -------- vDataFrame.aggregate : Computes\",\n \"optional Dictionary of the Random Forest model parameters used to\",\n \"kwargs: column = kwargs[\\\"column\\\"] else: check = False if check:\",\n \"({}) THEN {} || '' ELSE '{}' END)\\\".format( bin_spatial_to_str(self.category()), \\\",\",\n \"of vColumn distinct elements to be used as categorical. The\",\n \"to create a new category : 'Others'. cat_priority: list, optional\",\n \"upper_when = ( \\\"WHEN {} > {} THEN {} \\\".format(\\\"{}\\\",\",\n \"{} was converted to {}.\\\".format( self.alias, dtype ) ) return\",\n \"NULL LIMIT 0\\\".format( func.replace(\\\"{}\\\", self.alias), self.parent.__genSQL__(), self.alias, ), \\\"apply_test_feature\\\", )\",\n \"\\\" UNION ALL \\\".join(query), nbins - 1 ) result =\",\n \"0 self.catalog[\\\"mad\\\"] = 1 / 1.4826 elif method == \\\"zscore\\\":\",\n \"{} ASC LIMIT {}\\\".format( self.parent.__genSQL__(), self.alias, self.alias, n ) title\",\n \"\\\"is_numeric\\\" ): self.parent.__update_catalog__({\\\"index\\\": index, self.alias: result}) for elem in values:\",\n \"self.isnum() and method == \\\"smart\\\": schema = verticapy.options[\\\"temp_schema\\\"] if not\",\n \"sauv = {} for elem in self.catalog: sauv[elem] = self.catalog[elem]\",\n \"density( self, by: str = \\\"\\\", bandwidth: float = 1.0,\",\n \"the logic to the data. # # # Modules #\",\n \"# speed and built-in analytics and machine learning features. It\",\n \"int, optional Number of elements to skip. Returns ------- tablesample\",\n \"'same_freq'\\\" ) count = self.count() nb = int(float(count / int(nbins)))\",\n \"rose : Rose chart. It can also be a cutomized\",\n \"max_cardinality, h, donut, rose, ax=None, **style_kwds, ) # ---# def\",\n \"self.nunique(), self.isnum(), self.isdate(), ) if (is_date) and not (method ==\",\n \"({3}{4} USING PARAMETERS percentile = 0.9) AS 'approx_90%', MAX({3}{4}) AS\",\n \"**style_kwds, ): \\\"\\\"\\\" --------------------------------------------------------------------------- Draws the range plot of the\",\n \"**style_kwds, ): \\\"\\\"\\\" --------------------------------------------------------------------------- Draws the histogram of the vColumn\",\n \"expr += [ \\\"'{}', {}\\\".format(str(distinct_elements[k]).replace(\\\"'\\\", \\\"''\\\"), k) ] text_info +=\",\n \"testing to be able to look at the final transformation.\",\n \"h, [list, float, int]), ] ) if by: self.parent.are_namecols_in(by) by\",\n \"Numerical vColumn to use when the parameter method is set\",\n \"(SELECT {} AS {}, {} AS verticapy_agg FROM {} WHERE\",\n \"of = self.parent.format_colnames(of) from verticapy.plot import spider as spider_plot return\",\n \"self.alias, n ) title = \\\"Reads {} {} largest elements.\\\".format(self.alias,\",\n \"expression. \\\"\\\"\\\" self.parent.filter(\\\"{} IS NOT NULL\\\".format(self.alias)) return self.parent # ---#\",\n \"decrease. Returns ------- float quantile (or approximate quantile). See Also\",\n \"vColumn '{}' was transformed with the func 'x -> {}'.\\\".format(\",\n \"(\\\"nbins\\\", nbins, [int])]) self.parent.are_namecols_in(y) y = self.parent.format_colnames(y) assert self.parent[y].nunique() ==\",\n \"STDDEV({3}{4}) AS std, MIN({3}{4}) AS min, APPROXIMATE_PERCENTILE ({3}{4} USING PARAMETERS\",\n \"for elem in result if elem[2] != None ] ),\",\n \"start: int Start of the slicing. step: int Size of\",\n \"\\\"\\\"\\\" --------------------------------------------------------------------------- Converts the vColumn to the input type. Parameters\",\n \"- sauv[\\\"mean\\\"]) / sauv[ \\\"std\\\" ] elif method == \\\"minmax\\\":\",\n \"Returns True if the vColumn is numerical. \\\"\\\"\\\" return self.category()\",\n \"max_cardinality, [int, float]), (\\\"nbins\\\", nbins, [int, float]), (\\\"h\\\", h, [int,\",\n \"a user-defined encoding. vDataFrame[].discretize : Discretizes the vColumn. vDataFrame[].label_encode :\",\n \"'03-11-1993' will filter the data when 'ts' is lesser than\",\n \"+ \\\"{}%\\\".format(x * 100)]).values[self.alias][ 0 ] # ---# def range_plot(\",\n \"--------------------------------------------------------------------------- Extracts the regular expression in each record of the\",\n \"least 'lower' or 'upper' must have a numerical value\\\" )\",\n \"# ---# def avg(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using\",\n \") if method in (\\\"mean\\\", \\\"median\\\") or isinstance(val, float): category,\",\n \": Rose chart. It can also be a cutomized aggregation\",\n \"def drop(self, add_history: bool = True): \\\"\\\"\\\" --------------------------------------------------------------------------- Drops the\",\n \"self.category(), self.ctype() copy_trans = [elem for elem in self.transformations] total\",\n \"-------- vDataFrame.bar : Draws the Bar Chart of the input\",\n \"of the vColumn. The aggregations used are the median and\",\n \"Gaussian kernel. logistic : Logistic kernel. sigmoid : Sigmoid kernel.\",\n \"the vColumn is boolean, False otherwise. Returns ------- bool True\",\n \"------- ax Matplotlib axes object \\\"\\\"\\\" columns = [self.alias] check\",\n \"\\\"0ifnull\\\": new_column = \\\"DECODE({}, NULL, 0, 1)\\\" elif method in\",\n \"self.parent.format_colnames(y) assert self.parent[y].nunique() == 2, TypeError( \\\"vColumn {} must be\",\n \"columns=[self.alias]) self.catalog[\\\"count\\\"] = self.parent.shape()[0] self.catalog[\\\"percent\\\"] = 100 self.parent.__add_to_history__( \\\"[Label Encoding]:\",\n \"h: float, optional The interval size to convert to use\",\n \"vColumn. Parameters ---------- func: str, Function in pure SQL used\",\n \"vColumn. \\\"\\\"\\\" check_types( [ ( \\\"func\\\", func, [ \\\"abs\\\", \\\"acos\\\",\",\n \"if the parameter is empty or invalid. max_cardinality: int, optional\",\n \"float/str maximum See Also -------- vDataFrame.aggregate : Computes the vDataFrame\",\n \"vColumn with Label Encoding. vDataFrame[].mean_encode : Encodes the vColumn using\",\n \"sum : Sum of the vColumn 'of'. q% : q\",\n \"= True, ): \\\"\\\"\\\" --------------------------------------------------------------------------- Discretizes the vColumn using the\",\n \"the data when using TS methods. Returns ------- vDataFrame self.parent\",\n \"-------- vDataFrame[].decode : Encodes the vColumn using a user-defined encoding.\",\n \"-------- vDataFrame[].head : Returns the head of the vColumn. \\\"\\\"\\\"\",\n \"Draws the Geospatial object. Parameters ---------- *args / **kwargs Any\",\n \"(\\\"nbins\\\", nbins, [int, float]), ( \\\"method\\\", method, [\\\"auto\\\", \\\"smart\\\", \\\"same_width\\\",\",\n \"element. Parameters ---------- dropna: bool, optional If set to True,\",\n \"numerical aggregations during the computation. max_cardinality: int, optional Cardinality threshold\",\n \"the approximate quantile is returned. By setting this parameter to\",\n \"\\\"atan\\\", \\\"cbrt\\\", \\\"ceil\\\", \\\"cos\\\", \\\"cosh\\\", \\\"cot\\\", \\\"exp\\\", \\\"floor\\\", \\\"ln\\\", \\\"log\\\",\",\n \"(\\\"q\\\", q, [tuple]), ( \\\"start_date\\\", start_date, [str, datetime.datetime, datetime.date, int,\",\n \"[ (\\\"method\\\", method, [\\\"zscore\\\", \\\"robust_zscore\\\", \\\"minmax\\\"]), (\\\"by\\\", by, [list]), (\\\"return_trans\\\",\",\n \"list = [], ax=None, **style_kwds, ): \\\"\\\"\\\" --------------------------------------------------------------------------- Draws the\",\n \"if method != \\\"cat_stats\\\": values = { \\\"index\\\": [\\\"name\\\", \\\"dtype\\\"]\",\n \"used are the median and two input quantiles. Parameters ----------\",\n \"(method == \\\"mode\\\") and (val == None): val = self.mode(dropna=True)\",\n \"------- float average See Also -------- vDataFrame.aggregate : Computes the\",\n \"pt_events FROM ({}) x\\\".format( self.alias, query, ) query = \\\"SELECT\",\n \"True if the vColumn category is date. vDataFrame[].isnum : Returns\",\n \"'\\\"{}{}\\\"'.format( prefix, str(distinct_elements[k]).replace('\\\"', \\\"_\\\") ) ) name = ( name.replace(\\\"\",\n \"is very useful for testing to be able to look\",\n \"({name}).\\\\n\\\" \\\"It can be the result of using previously the\",\n \"of distinct elements for vColumns 1 and 2 to be\",\n \"slice): assert index.step in (1, None), ValueError( \\\"vColumn doesn't allow\",\n \"int, optional Maximum number of points to use to evaluate\",\n \"response: str = \\\"\\\", return_enum_trans: bool = False, ): \\\"\\\"\\\"\",\n \"str = \\\"auto\\\", ax=None, **style_kwds, ): \\\"\\\"\\\" --------------------------------------------------------------------------- Draws the\",\n \"vColumn is numerical or of type date like. Optimized h\",\n \"\\\\/ / / # / / # / / #\",\n \"BY {}\\\".format( \\\", \\\".join([quote_ident(column) for column in by]) ) if\",\n \"# ---# def store_usage(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns the vColumn expected\",\n \"columns=[self.alias]) total = abs(self.count() - total) except Exception as e:\",\n \"\\\"spearmand\\\": {}, \\\"kendall\\\": {}, \\\"cramer\\\": {}, \\\"biserial\\\": {}, \\\"regr_avgx\\\": {},\",\n \"/ int / float / text / binary / spatial\",\n \"self.parent.__add_to_history__( \\\"[Label Encoding]: Label Encoding was applied to the vColumn\",\n \"\\\"min\\\": 0, \\\"max\\\": 1, \\\"count\\\": self.parent.shape()[0], \\\"percent\\\": 100.0, \\\"unique\\\": 2,\",\n \"from verticapy.plot import gen_colors from matplotlib.lines import Line2D colors =\",\n \"the vDataFrame represents the entire relation, a vColumn can be\",\n \"# ---# def sub(self, x: float): \\\"\\\"\\\" --------------------------------------------------------------------------- Subtracts the\",\n \"self.distinct() expr = [\\\"DECODE({}\\\"] text_info = \\\"\\\\n\\\" for k in\",\n \"digits after the comma. Parameters ---------- n: int Number of\",\n \"column in all_cols: try: if (quote_ident(column) in func) or (\",\n \"Parameters ---------- breaks: list List of values used to cut\",\n \"\\\"AVG({}) OVER (PARTITION BY {})\\\".format( self.alias, \\\", \\\".join(by) ), \\\"STDDEV({})\",\n \"of correlated features. use_numbers_as_suffix: bool, optional Uses numbers as suffix\",\n \"as percents. Parameters ---------- k: int, optional Number of most\",\n \"\\\"\\\"\\\" check_types([(\\\"k\\\", k, [int, float]), (\\\"dropna\\\", dropna, [bool])]) topk =\",\n \"Normalization\\\") return self.parent # ---# def nsmallest(self, n: int =\",\n \"New type. Returns ------- vDataFrame self.parent See Also -------- vDataFrame.astype\",\n \"may obtain a copy of the License at # #\",\n \"not normalize {} using the MIN and the MAX. MAX\",\n \"\\\"ABS({} - {}) / {} < {}\\\".format( self.alias, result[\\\"avg\\\"][0], result[\\\"std\\\"][0],\",\n \"'sem' (standard error of mean). Returns ------- float sem See\",\n \"if isinstance(val, str): val = val.replace(\\\"'\\\", \\\"''\\\") if val !=\",\n \"self.parent.__add_to_history__( \\\"[Mean Encode]: The vColumn {} was transformed using a\",\n \"= [ \\\"(SELECT READ_TREE(USING PARAMETERS model_name = '{}', tree_id =\",\n \"Encoding. vDataFrame[].get_dummies : Encodes the vColumn with One-Hot Encoding. vDataFrame[].label_encode\",\n \"aggregations. \\\"\\\"\\\" return self.aggregate([\\\"stddev\\\"]).values[self.alias][0] stddev = std # ---# def\",\n \"Parameters ---------- x: float If the vColumn type is date\",\n \"DECADE / DOQ / DOW / DOY / EPOCH /\",\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 \"alpha: float = 0.05 ): \\\"\\\"\\\" --------------------------------------------------------------------------- Drops outliers in\",\n \"0: limit = 0 limit = \\\" LIMIT {}\\\".format(limit) else:\",\n \"vColumn with user defined Encoding. vDataFrame[].discretize : Discretizes the vColumn.\",\n \"for conducting # data science projects on data stored in\",\n \"from verticapy.plot import gen_cmap kwargs[\\\"cmap\\\"] = gen_cmap()[0] else: if not\",\n \"Information Value (IV) / Weight Of Evidence (WOE) Table. It\",\n \": exponential function floor : value down to the next\",\n \"\\\"backfill\\\", ], ), (\\\"expr\\\", expr, [str]), (\\\"by\\\", by, [list]), (\\\"order_by\\\",\",\n \"self.parent.__update_catalog__(erase=True, columns=[self.alias]) total = abs(self.count() - total) except Exception as\",\n \"self.parent[copy_name].transformations += [ (\\\"{}\\\", self.ctype(), self.category()) ] self.parent[copy_name].transformations += [(func,\",\n \"bound quantile(alpha) and as upper bound quantile(1-alpha) if 'use_threshold' is\",\n \"self.parent.filter( \\\"({} BETWEEN {} AND {})\\\".format(self.alias, p_alpha, p_1_alpha) ) return\",\n \"Computes the vDataFrame input aggregations. \\\"\\\"\\\" return self.aggregate([\\\"avg\\\"]).values[self.alias][0] mean =\",\n \"If set to True, the record will be sliced using\",\n \"kernel, [\\\"gaussian\\\", \\\"logistic\\\", \\\"sigmoid\\\", \\\"silverman\\\"]), (\\\"bandwidth\\\", bandwidth, [int, float]), (\\\"nbins\\\",\",\n \"is in each of the vColumn records. vDataFrame[].str_count : Computes\",\n \"self.category() == \\\"date\\\" # ---# def isin(self, val: list, *args):\",\n \"---# def topk(self, k: int = -1, dropna: bool =\",\n \"ZEROIFNULL(LN(pt_non_events / NULLIFZERO(pt_events))) END AS woe, CASE WHEN non_events =\",\n \"if \\\"percent\\\" in elem: self.catalog[elem] = sauv[elem] elif elem ==\",\n \"of two flower brackets {}. For example to apply the\",\n \"True, draw an Area Plot. step: bool, optional If set\",\n \"ORDER BY _verticapy_cnt_ ASC LIMIT 1\\\".format( self.alias, self.alias, self.parent.__genSQL__(), where,\",\n \"vColumn type is date like (date, datetime ...), the parameter\",\n \"see utilities.tablesample. See Also -------- vDataFrame[].tail : Returns the a\",\n \"on an \\\"AS IS\\\" BASIS, # WITHOUT WARRANTIES OR CONDITIONS\",\n \"the vDataFrame input aggregations. \\\"\\\"\\\" return self.aggregate([\\\"min\\\"]).values[self.alias][0] # ---# def\",\n \"{new_name}.\\\\nBy changing the parameter 'new_name', you'll be able to solve\",\n \"performance can drastically decrease. Returns ------- float/str median See Also\",\n \"\\\"SELECT {} AS apply_test_feature FROM {} WHERE {} IS NOT\",\n \"list Distinct caterogies of the vColumn. See Also -------- vDataFrame.topk\",\n \"values will not be considered during the computation. n: int,\",\n \"include_lowest: op1, close_l = \\\"<=\\\", \\\"[\\\" elif idx == 0:\",\n \"str_slice(self, start: int, step: int): \\\"\\\"\\\" --------------------------------------------------------------------------- Slices the vColumn.\",\n \"vDataFrame input aggregations. \\\"\\\"\\\" return self.aggregate([\\\"sum\\\"]).values[self.alias][0] # ---# def tail(self,\",\n \"(method == \\\"median\\\") else \\\"AVG\\\" if by == []: if\",\n \"= self.catalog[elem] self.parent.__update_catalog__(erase=True, columns=[self.alias]) total = abs(self.count() - total) except\",\n \"RFmodel_params: dict, optional Dictionary of the Random Forest model parameters\",\n \"self.parent.shape()[0] - limit) title = \\\"Reads {}.\\\".format(self.alias) tail = to_tablesample(\",\n \"{ \\\"cov\\\": {}, \\\"pearson\\\": {}, \\\"spearman\\\": {}, \\\"spearmand\\\": {}, \\\"kendall\\\":\",\n \"the vDataFrame input aggregations. \\\"\\\"\\\" return self.aggregate([\\\"sum\\\"]).values[self.alias][0] # ---# def\",\n \"/ TIMEZONE_HOUR / TIMEZONE_MINUTE / WEEK / YEAR Returns -------\",\n \"return self.parent # ---# def fillna( self, val=None, method: str\",\n \"be numerical to use a mean encoding\\\" ) max_floor =\",\n \": 'Others'. cat_priority: list, optional List of the different categories\",\n \"total += nb where = \\\"WHERE _verticapy_row_nb_ IN ({})\\\".format( \\\",\",\n \"non_events / NULLIFZERO(SUM(non_events) OVER ()) AS pt_non_events, events / NULLIFZERO(SUM(events)\",\n \"is empty or invalid. max_cardinality: int/tuple, optional Maximum number of\",\n \"aggregation. Parameters ---------- method: str, optional The method to use\",\n \"when 'ts' is greater than November 1993 the 3rd. area:\",\n \"define the outliers. After normalizing the data (Z-Score), if the\",\n \"the input element to the vColumn. Parameters ---------- x: float\",\n \"False, the function's performance can drastically decrease. Returns ------- float\",\n \"\\\" WHERE {} IS NOT NULL\\\".format(self.alias) if (dropna) else \\\"\\\"\",\n \"dtype), dtype, get_category_from_vertica_type(ctype=dtype), ) ] self.parent.__add_to_history__( \\\"[AsType]: The vColumn {}\",\n \"skewness sum : sum std : standard deviation topk :\",\n \"result], } return tablesample(values) # ---# def value_counts(self, k: int\",\n \"use_threshold: bool = True, alpha: float = 0.05, ): \\\"\\\"\\\"\",\n \"Deviation is null !\\\".format( self.alias ) warnings.warn(warning_message, Warning) return self\",\n \"the record is greater than the threshold it will be\",\n \"the Store Usage of the vColumn {}.\\\".format(self.alias), method=\\\"fetchfirstelem\\\", ) self.parent.__update_catalog__(\",\n \"def min(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using 'min' (Minimum).\",\n \"= \\\"auto\\\", ax=None, **style_kwds, ): \\\"\\\"\\\" --------------------------------------------------------------------------- Draws the pie\",\n \"Clips the vColumn using as lower bound quantile(alpha) and as\",\n \"{}{} OFFSET {}{}) VERTICAPY_SUBTABLE\\\".format( self.alias, self.parent.__genSQL__(), self.parent.__get_last_order_by__(), index_start, limit, )\",\n \"float]), ] ) if use_threshold: result = self.aggregate(func=[\\\"std\\\", \\\"avg\\\"]).transpose().values p_alpha,\",\n \"WHEN non_events = 0 OR events = 0 THEN 0\",\n \"pie_type: str = \\\"auto\\\", ax=None, **style_kwds, ): \\\"\\\"\\\" --------------------------------------------------------------------------- Draws\",\n \"an aggregation. Parameters ---------- by: str, optional vColumn to use\",\n \"--------------------------------------------------------------------------- Returns the vColumn DB type. Returns ------- str vColumn\",\n \"Each transformation must be similar to the following: (function, type,\",\n \"assert self.isnum() or self.isdate(), TypeError( \\\"cut only works on numerical\",\n \"is in ffill|pad|bfill|backfill then 'order_by' must be a list of\",\n \"Returns True if the vColumn is boolean. vDataFrame[].isdate : Returns\",\n \"optional The bandwidth of the kernel. kernel: str, optional The\",\n \"self.transformations += [trans] sauv = {} for elem in self.catalog:\",\n \"elements to return. Returns ------- tablesample An object containing the\",\n \") self.parent.are_namecols_in(ts) ts = self.parent.format_colnames(ts) if by: self.parent.are_namecols_in(by) by =\",\n \"method 'same_freq'\\\" ) count = self.count() nb = int(float(count /\",\n \"len(all_new_features) > 1 else \\\" was \\\" self.parent.__add_to_history__( \\\"[Get Dummies]:\",\n \"vColumn. \\\"\\\"\\\" check_types( [ (\\\"length\\\", length, [int, float]), (\\\"unit\\\", unit,\",\n \"[sum(result[\\\"non_events\\\"])] result.values[\\\"events\\\"] += [sum(result[\\\"events\\\"])] result.values[\\\"pt_non_events\\\"] += [\\\"\\\"] result.values[\\\"pt_events\\\"] += [\\\"\\\"]\",\n \"== \\\"robust_zscore\\\": self.catalog[\\\"median\\\"] = 0 self.catalog[\\\"mad\\\"] = 1 / 1.4826\",\n \"number of the vColumn distinct elements to be used as\",\n \"{} ELSE {} END)\\\".format( \\\"{}\\\", p_alpha, mean_alpha, \\\"{}\\\", p_1_alpha, mean_1_alpha,\",\n \"optional If set to True, the information will be stored\",\n \"be stored in the vDataFrame history. Returns ------- vDataFrame self.parent\",\n \"each vColumn category. In this case, the parameter 'numcol' must\",\n \"'upper' must have a numerical value\\\" ) lower_when = (\",\n \"not (\\\"legend\\\" in kwargs): kwargs[\\\"legend\\\"] = True if not (\\\"figsize\\\"\",\n \"query = \\\"(SELECT {} FROM {}{} OFFSET {}{}) VERTICAPY_SUBTABLE\\\".format( self.alias,\",\n \"- 1], result[i] ) trans += \\\" ELSE NULL END)\\\"\",\n \"the vColumn 'of' (ex: 50% to get the median). It\",\n \"quantiles. Parameters ---------- ts: str TS (Time Series) vColumn to\",\n \"undefined Returns ------- str vColumn category. See Also -------- vDataFrame[].ctype\",\n \"self.alias, bin_spatial_to_str(self.category(), self.alias), self.alias, kwargs[\\\"agg\\\"], self.parent.__genSQL__(), self.alias, ) query_result =\",\n \"number of non-missing elements cvar : conditional value at risk\",\n \"tail = to_tablesample( \\\"SELECT {} AS {} FROM {}{} LIMIT\",\n \"aggregations. \\\"\\\"\\\" return self.aggregate([\\\"min\\\"]).values[self.alias][0] # ---# def mode(self, dropna: bool\",\n \"chart. It can also be a cutomized aggregation (ex: AVG(column1)\",\n \"|_)\\\\/ |_)(_|(_|| \\\\_/|_|(_||| # / # ____________ ______ # /\",\n \"-------- vDataFrame[].str_contains : Verifies if the regular expression is in\",\n \"new_column.format(self.alias), self.parent.__genSQL__() ), print_time_sql=False, ) except: new_column = \\\"COALESCE({}, {}({})\",\n \"compute the aggregation. h: int/float/tuple, optional Interval width of the\",\n \"added to the vDataFrame.\\\".format( self.alias, name ) ) return self.parent\",\n \"self.category())] self.transformations += [ (\\\"AVG({}) OVER (PARTITION BY {})\\\".format(response, \\\"{}\\\"),\",\n \"# ---# def decode(self, *argv): \\\"\\\"\\\" --------------------------------------------------------------------------- Encodes the vColumn\",\n \"BY {}))\\\".format( \\\"{}\\\", fun, \\\"{}\\\", \\\", \\\".join(by) ) else: new_column\",\n \"= sauv[elem] elif elem == None: self.catalog[elem] = None elif\",\n \"the vColumn using a time series rule. \\\"\\\"\\\" return self.apply(func=\\\"DATE_PART('{}',\",\n \"UNION ALL \\\".join(query) ) title = \\\"Describes the statics of\",\n \"vDataFrame input aggregations. \\\"\\\"\\\" check_types([(\\\"x\\\", x, [int, float], (\\\"approx\\\", approx,\",\n \"\\\"cat_stats\\\": values = { \\\"index\\\": [\\\"name\\\", \\\"dtype\\\"] + index, \\\"value\\\":\",\n \"round(h, 6) if self.category() == \\\"int\\\": h = int(max(math.floor(h), 1))\",\n \"\\\"max_depth\\\": 10} to train a Random Forest with 20 trees\",\n \"self.catalog[\\\"percent\\\"] = ( 100 * (int(sauv[\\\"count\\\"]) + total) / self.parent.shape()[0]\",\n \"ParameterError( \\\"Length of parameter breaks must be equal to the\",\n \"\\\"percent\\\": 100.0, \\\"unique\\\": 2, \\\"approx_unique\\\": 2, \\\"prod\\\": 0, }, )\",\n \"optional Method to use to impute the missing values. auto\",\n \"/ self.parent.shape()[0] ) except: pass self.parent.__add_to_history__( \\\"[Discretize]: The vColumn {}\",\n \"the parameter 'name', you'll be able to solve this issue.\\\"\",\n \"occurent elements to return. Returns ------- tablesample An object containing\",\n \"h = round(h, 6) if self.category() == \\\"int\\\": h =\",\n \"0.25) AS 'approx_25%', APPROXIMATE_PERCENTILE ({3}{4} USING PARAMETERS percentile = 0.5)\",\n \"the filling.\\\".format(e)) if total > 0: try: if \\\"count\\\" in\",\n \"result[7], ) elif self.isdate(): min_date = self.min() table = \\\"(SELECT\",\n \"1): first_elem, second_elem = breaks[idx], breaks[idx + 1] if right:\",\n \"be updated when the parent vDataFrame is modified. Attributes ----------\",\n \"# \\\\ \\\\__| \\\\ \\\\_____\\\\ \\\\ \\\\_____\\\\ \\\\ \\\\_____\\\\ \\\\\",\n \"\\\"\\\"\\\" --------------------------------------------------------------------------- Adds a copy vColumn to the parent vDataFrame.\",\n \"+ [(expr, \\\"bool\\\", \\\"int\\\")] new_vColumn = vColumn( name, parent=self.parent, transformations=transformations,\",\n \"\\\"\\\"\\\" return self.category() == \\\"date\\\" # ---# def isin(self, val:\",\n \"digits to keep after the comma. Returns ------- vDataFrame self.parent\",\n \"self.parent.shape()[0] if isinstance(index_stop, int): if index_stop < 0: index_stop +=\",\n \"of discretization using the method 'smart'.\\\" ) assert response, ParameterError(\",\n \"\\\" DESC\\\" partition_by = ( \\\"PARTITION BY {}\\\".format( \\\", \\\".join([quote_ident(column)\",\n \"---# def spider( self, by: str = \\\"\\\", method: str\",\n \"if method != \\\"robust_zscore\\\": max_floor = 0 for elem in\",\n \"expression is in each of the vColumn records. vDataFrame[].extract :\",\n \"[ (\\\"ts\\\", ts, [str]), (\\\"by\\\", by, [str]), (\\\"start_date\\\", start_date, [str,\",\n \"\\\"\\\", \\\"\\\" for category in cat: tmp_query = \\\"\\\"\\\"SELECT '{0}'\",\n \"category : 'Others'. cat_priority: list, optional List of the different\",\n \"quantile(alpha) and as upper bound quantile(1-alpha) if 'use_threshold' is set\",\n \"with 0 and 1 (1 meaning global outlier). \\\"\\\"\\\" check_types(\",\n \"-------- vDataFrame[].fill_outliers : Fills the vColumn outliers using the input\",\n \"____________ ______ # / __ `\\\\ / / # |\",\n \"min, APPROXIMATE_PERCENTILE({} USING PARAMETERS percentile = 0.25) AS Q1, APPROXIMATE_PERCENTILE({}\",\n \"self.parent.are_namecols_in(response) response = self.parent.format_colnames(response) assert self.parent[response].isnum(), TypeError( \\\"The response column\",\n \"{} ELSE NULL END)\\\".format( \\\"{}\\\", p_alpha, p_1_alpha, \\\"{}\\\" ) )\",\n \"bar return bar(self, method, of, max_cardinality, nbins, h, ax=ax, **style_kwds)\",\n \") query = \\\"SELECT {} AS index, non_events, events, pt_non_events,\",\n \"WHERE {} IS NOT NULL GROUP BY 1) x ORDER\",\n \"gain in performance. The catalog will be updated when the\",\n \"str, Function in pure SQL used to transform the vColumn.\",\n \"the number of matches for the regular expression in each\",\n \"+= \\\"\\\\t{} => {}\\\".format(distinct_elements[k], k) expr = \\\", \\\".join(expr) +\",\n \"the head of the vColumn. \\\"\\\"\\\" return self.iloc(limit=limit, offset=-1) #\",\n \"\\\"_\\\") .replace(\\\"/\\\", \\\"_\\\") .replace(\\\",\\\", \\\"_\\\") .replace(\\\"'\\\", \\\"_\\\") ) expr =\",\n \"h > 0.000001: h = round(h, 6) if self.category() ==\",\n \"/ Weight Of Evidence (WOE) Table. It tells the predictive\",\n \"def str_replace(self, to_replace: str, value: str = \\\"\\\"): \\\"\\\"\\\" ---------------------------------------------------------------------------\",\n \") count = self.count() nb = int(float(count / int(nbins))) assert\",\n \"result] elif self.isnum() and method in (\\\"same_width\\\", \\\"auto\\\"): if not\",\n \"the vColumn is numerical, False otherwise. Returns ------- bool True\",\n \"xlim=(xmin, xmax), ax=ax, **updated_dict(param, style_kwds, idx), ) custom_lines += [\",\n \": remainder of a division operation pow : number raised\",\n \"parameter 'labels' must be empty.\\\" ) conditions, column = [],\",\n \"2): \\\"\\\"\\\" --------------------------------------------------------------------------- Applies a default function to the vColumn.\",\n \": Number of elements. density : Percentage of the distribution.\",\n \"elem[2] if elem[2] != None else \\\"NULL\\\", ) for elem\",\n \"[name] all_new_features += [name] conj = \\\"s were \\\" if\",\n \"ParameterError( \\\"At least 'lower' or 'upper' must have a numerical\",\n \"\\\"\\\" if (k < 1) else \\\"LIMIT {}\\\".format(k) dropna =\",\n \"vColumn is boolean, False otherwise. Returns ------- bool True if\",\n \"self.parent.format_colnames(by) nullifzero, n = 1, len(by) if self.isbool(): warning_message =\",\n \"self.aggregate([\\\"aad\\\"]).values[self.alias][0] # ---# def abs(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Applies the absolute\",\n \"the input functions. Parameters ---------- func: list List of the\",\n \"( 100 * (int(sauv[\\\"count\\\"]) + total) / self.parent.shape()[0] ) except:\",\n \"nth most occurent element. See Also -------- vDataFrame.aggregate : Computes\",\n \"sum(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using 'sum'. Returns -------\",\n \": percent of non-missing elements q% : q quantile (ex:\",\n \"based on an aggregation. \\\"\\\"\\\" check_types( [ (\\\"by\\\", by, [str]),\",\n \"(PARTITION BY {}))\\\".format( \\\"{}\\\", fun, \\\"{}\\\", \\\", \\\".join(by) ) elif\",\n \"tells the predictive power of an independent variable in relation\",\n \"when drawing the box plot. The other categories will be\",\n \"the equal frequency histogram bins.\\\", method=\\\"fetchall\\\", ) result = [elem[0]\",\n \"float): category, ctype = \\\"float\\\", \\\"float\\\" elif method == \\\"0ifnull\\\":\",\n \"pat, [str])]) return self.apply( func=\\\"REGEXP_SUBSTR({}, '{}')\\\".format(\\\"{}\\\", pat.replace(\\\"'\\\", \\\"''\\\")) ) #\",\n \"response = self.parent.format_colnames(response) assert self.parent[response].isnum(), TypeError( \\\"The response column must\",\n \"limit) title = \\\"Reads {}.\\\".format(self.alias) tail = to_tablesample( \\\"SELECT {}\",\n \"q, [tuple]), ( \\\"start_date\\\", start_date, [str, datetime.datetime, datetime.date, int, float],\",\n \"self.parent See Also -------- vDataFrame[].drop_outliers : Drops outliers in the\",\n \"\\\"\\\"\\\" --------------------------------------------------------------------------- Discretizes the vColumn using the input method. Parameters\",\n \"\\\"'{}'\\\".format(str(elem[0]).replace(\\\"'\\\", \\\"''\\\")) if elem[0] != None else \\\"NULL\\\", elem[1] if\",\n \"= \\\"\\\", area: bool = False, step: bool = False,\",\n \"str = \\\"\\\", max_cardinality: Union[int, tuple] = (6, 6), h:\",\n \"in kwargs): kwargs[\\\"figsize\\\"] = (14, 10) return self.parent[columns].to_geopandas(self.alias).plot(*args, **kwargs) #\",\n \"\\\"WITH vdf_table AS (SELECT * FROM {}) {}\\\".format( self.parent.__genSQL__(), query\",\n \"self.apply(func=\\\"DATE_PART('{}', {})\\\".format(field, \\\"{}\\\")) # ---# def decode(self, *argv): \\\"\\\"\\\" ---------------------------------------------------------------------------\",\n \"\\\"{} = '{}'\\\".format(self.parent[by].alias, column) )[self.alias].density( bandwidth=bandwidth, kernel=kernel, nbins=nbins, xlim=(xmin, xmax),\",\n \"information, see utilities.tablesample. See Also -------- vDataFrame.analytic : Adds a\",\n \"self.parent.are_namecols_in(ts) ts = self.parent.format_colnames(ts) from verticapy.plot import range_curve_vdf return range_curve_vdf(\",\n \"the Information Value (IV) / Weight Of Evidence (WOE) Table.\",\n \"+ sys.getsizeof(self.catalog) ) for elem in self.catalog: total += sys.getsizeof(elem)\",\n \"int Size of the slicing. Returns ------- vDataFrame self.parent See\",\n \"be considered during the computation. n: int, optional Integer corresponding\",\n \"== None: mean_alpha = \\\"NULL\\\" self.apply( func=\\\"(CASE WHEN {} <\",\n \"int): cast = \\\"::float\\\" if self.category() == \\\"float\\\" else \\\"\\\"\",\n \"[int, float]), (\\\"h\\\", h, [int, float]), (\\\"cat_priority\\\", cat_priority, [list]), ]\",\n \"parameters used to compute the best splits when 'method' is\",\n \"] ) method = method.lower() self.parent.are_namecols_in([elem for elem in order_by]\",\n \"= \\\"\\\", max_cardinality: int = 6, nbins: int = 0,\",\n \"def var(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using 'var' (Variance).\",\n \"return boxplot(self, by, h, max_cardinality, cat_priority, ax=ax, **style_kwds) # ---#\",\n \"normalize {} using a Robust Z-Score - The MAD is\",\n \"describe method. auto : Sets the method to 'numerical' if\",\n \"[column] if not (\\\"cmap\\\" in kwargs): from verticapy.plot import gen_cmap\",\n \"executeSQL( \\\"SELECT {}, {} FROM {} LIMIT 1\\\".format( avg, stddev,\",\n \"\\\"\\\"\\\" --------------------------------------------------------------------------- Returns True if the vColumn is boolean, False\",\n \"# ---# def str_extract(self, pat: str): \\\"\\\"\\\" --------------------------------------------------------------------------- Extracts the\",\n \"in result], \\\"percent\\\": [float(round(item[2], 3)) for item in result], }\",\n \"\\\"\\\"\\\" check_types([(\\\"to_replace\\\", to_replace, [str]), (\\\"value\\\", value, [str])]) return self.apply( func=\\\"REGEXP_REPLACE({},\",\n \"vColumn {} was transformed using a mean encoding with {}\",\n \"\\\\ \\\\'/ \\\\ \\\\ \\\\____ \\\\ \\\\ \\\\/\\\\ \\\\ \\\\\",\n \"max : maximum mean : average median : median min\",\n \"import verticapy.stats as st return self.apply(func=st.decode(str_sql(\\\"{}\\\"), *argv)) # ---# def\",\n \"USING PARAMETERS percentile = 0.9) AS 'approx_90%', MAX({3}{4}) AS max\",\n \"categories to normalize.\\\", method=\\\"fetchall\\\", ) for i in range(len(result)): if\",\n \"---# def nunique(self, approx: bool = True): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates\",\n \"max_cardinality: int, optional Maximum number of vColumn distinct elements to\",\n \"discretization using the method 'same_freq'\\\" ) count = self.count() nb\",\n \"already the alias {name}.\\\\nBy changing the parameter 'name', you'll be\",\n \"\\\"VERTICAPY_NOT_PRECOMPUTED\\\": if not (dropna) and (pre_comp != None): return pre_comp\",\n \"---# def iv_woe(self, y: str, nbins: int = 10): \\\"\\\"\\\"\",\n \">= 2, ParameterError( \\\"Length of parameter 'breaks' must be greater\",\n \"Uses the Random Forest on a response column to find\",\n \"------- vDataFrame self.parent See Also -------- vDataFrame[].decode : Encodes the\",\n \"/ 3)] sturges : Sturges [CEIL(log2(n)) + 1] Returns -------\",\n \"winsorize : Clips the vColumn using as lower bound quantile(alpha)\",\n \"return top # ---# def mul(self, x: float): \\\"\\\"\\\" ---------------------------------------------------------------------------\",\n \"values = to_tablesample(query, title=title).values elif ( ((distinct_count < max_cardinality +\",\n \") for elem in self.catalog: total += sys.getsizeof(elem) return total\",\n \"using 'avg' (Average). Returns ------- float average See Also --------\",\n \"self.parent.__genSQL__(), dropna, self.alias, topk, ) result = executeSQL( query, title=\\\"Computing\",\n \"0 if index_start < 0: index_start += self.parent.shape()[0] if isinstance(index_stop,\",\n \"into one unique category. h: float, optional The interval size\",\n \"Label Encoding. vDataFrame[].mean_encode : Encodes the vColumn using the mean\",\n \"the input expression. \\\"\\\"\\\" self.parent.filter(\\\"{} IS NOT NULL\\\".format(self.alias)) return self.parent\",\n \"index = [\\\"unique\\\", \\\"count\\\"] + [item[0] for item in query_result]\",\n \"for testing to be able to look at the final\",\n \"histogram of the vColumn based on an aggregation. Parameters ----------\",\n \"a Step Plot. ax: Matplotlib axes object, optional The axes\",\n \"distinct_elements = self.distinct() expr = [\\\"DECODE({}\\\"] text_info = \\\"\\\\n\\\" for\",\n \"to the input vColumn. \\\"\\\"\\\" check_types([(\\\"x\\\", x, [int, float])]) if\",\n \"use to discretize the vColumn. auto : Uses method 'same_width'\",\n \"(\\\"method\\\", method, [\\\"winsorize\\\", \\\"null\\\", \\\"mean\\\"]), (\\\"alpha\\\", alpha, [int, float]), (\\\"use_threshold\\\",\",\n \"med, mad), \\\"float\\\", \\\"float\\\", ) ] else: warning_message = \\\"Can\",\n \"for item in self.transformations], catalog=self.catalog, ) setattr(self.parent, name, new_vColumn) setattr(self.parent,\",\n \"0, ax=None, **style_kwds, ): \\\"\\\"\\\" --------------------------------------------------------------------------- Draws the bar chart\",\n \"use to normalize. zscore : Normalization using the Z-Score (avg\",\n \"second argument. Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].apply\",\n \") executeSQL( \\\"SELECT {} FROM {} LIMIT 1\\\".format( new_column.format(self.alias), self.parent.__genSQL__()\",\n \"\\\\ / / / # \\\\/ / / # /\",\n \"bound to the lower bound itself and the values higher\",\n \"\\\"\\\"\\\" if isinstance(pie_type, str): pie_type = pie_type.lower() check_types( [ (\\\"method\\\",\",\n \"on an aggregation. \\\"\\\"\\\" check_types( [ (\\\"by\\\", by, [str]), (\\\"kernel\\\",\",\n \"\\\".join(all_new_features) ) + \\\".\\\" ) return self.parent one_hot_encode = get_dummies\",\n \"query = \\\"WITH vdf_table AS (SELECT * FROM {}) (SELECT\",\n \"vColumn_min, vColumn_025, vColumn_075, vColumn_max = ( result[0], result[3], result[4], result[6],\",\n \"by = self.parent.format_colnames(by) from verticapy.plot import ts_plot return ts_plot( self,\",\n \"kernel: str = \\\"gaussian\\\", nbins: int = 200, xlim: tuple\",\n \"integer k of the 'topk' method. new_category: str, optional The\",\n \"optional Uses the Gaussian distribution to define the outliers. After\",\n \"return self.apply(func=\\\"{} / ({})\\\".format(\\\"{}\\\", x)) # ---# def drop(self, add_history:\",\n \"== \\\"robust_zscore\\\": if n > 0: warning_message = \\\"The method\",\n \"case of discretization using the method 'same_freq'\\\" ) count =\",\n \"ts_plot( self, ts, by, start_date, end_date, area, step, ax=ax, **style_kwds,\",\n \"vDataFrame.plot : Draws the time series. \\\"\\\"\\\" check_types( [ (\\\"ts\\\",\",\n \"\\\", \\\".join([\\\"1\\\"] + nth_elems + [str(count)]) ) query = \\\"SELECT\",\n \"APPROXIMATE_PERCENTILE ({3}{4} USING PARAMETERS percentile = 0.75) AS 'approx_75%', APPROXIMATE_PERCENTILE\",\n \"outliers in the vColumn. Parameters ---------- threshold: float, optional Uses\",\n \"if n > 0: warning_message = \\\"The method 'robust_zscore' is\",\n \"used to compute other vColumns. Parameters ---------- add_history: bool, optional\",\n \") if method == \\\"winsorize\\\": self.clip(lower=p_alpha, upper=p_1_alpha) elif method ==\",\n \"use to partition the TS. start_date: str / date, optional\",\n \"self.parent See Also -------- vDataFrame[].dropna : Drops the vColumn missing\",\n \"\\\"\\\"\\\" check_types( [ (\\\"RFmodel_params\\\", RFmodel_params, [dict]), (\\\"return_enum_trans\\\", return_enum_trans, [bool]), (\\\"h\\\",\",\n \"bool, optional If set to True, the information will be\",\n \"ffill|pad|bfill|backfill then 'order_by' must be a list of at least\",\n \"std # ---# def store_usage(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns the vColumn\",\n \"a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 #\",\n \"vColumn using multiple statistical aggregations: min, max, median, unique... depending\",\n \") else: trans = (\\\"FLOOR({}) || ''\\\", \\\"varchar\\\", \\\"text\\\") else:\",\n \"--------------------------------------------------------------------------- Replaces the regular expression matches in each of the\",\n \"[int, float]), ( \\\"method\\\", method, [\\\"auto\\\", \\\"smart\\\", \\\"same_width\\\", \\\"same_freq\\\", \\\"topk\\\"],\",\n \"the Equal Frequency discretization\\\" ) total, query, nth_elems = nb,\",\n \"final_transformation = [ ( \\\"({} - {}) / {}({})\\\".format( \\\"{}\\\",\",\n \"the vColumn with One-Hot Encoding. vDataFrame[].mean_encode : Encodes the vColumn\",\n \"'skewness'. Returns ------- float skewness See Also -------- vDataFrame.aggregate :\",\n \"vDataFrame[].decode : Encodes the vColumn with a user defined Encoding.\",\n \") ) else: p_alpha, p_1_alpha = ( self.parent.quantile([alpha, 1 -\",\n \"approx=approx) # ---# def memory_usage(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns the vColumn\",\n \"cmin, ), \\\"float\\\", \\\"float\\\", ) ] if method != \\\"robust_zscore\\\":\",\n \"BY count DESC\\\" ).format(self.alias, max_cardinality + 1) query = \\\"WITH\",\n \"elif self.isnum() and method == \\\"same_freq\\\": assert nbins >= 2,\",\n \"[ (\\\"AVG({}) OVER (PARTITION BY {})\\\".format(response, \\\"{}\\\"), \\\"int\\\", \\\"float\\\") ]\",\n \") title = \\\"Computing WOE & IV of {} (response\",\n \"outliers using the input method. \\\"\\\"\\\" check_types([(\\\"lower\\\", lower, [float, int]),\",\n \"------- tablesample An object containing the result. For more information,\",\n \"# ---# def numh(self, method: str = \\\"auto\\\"): \\\"\\\"\\\" ---------------------------------------------------------------------------\",\n \"{}, \\\"regr_avgx\\\": {}, \\\"regr_avgy\\\": {}, \\\"regr_count\\\": {}, \\\"regr_intercept\\\": {}, \\\"regr_r2\\\":\",\n \"(is_date) and not (method == \\\"categorical\\\"): result = self.aggregate([\\\"count\\\", \\\"min\\\",\",\n \"Z-Score (avg and std). (x - avg) / std robust_zscore\",\n \"None elif method == \\\"robust_zscore\\\": self.catalog[elem] = (sauv[elem] - sauv[\\\"approx_50%\\\"])\",\n \"by = self.parent.format_colnames(by) from verticapy.plot import gen_colors from matplotlib.lines import\",\n \"False otherwise. Returns ------- bool True if the vColumn category\",\n \"End Date. For example, time = '03-11-1993' will filter the\",\n \"float, optional Number representing the outliers threshold. Values lesser than\",\n \"FROM vdf_table WHERE {0} IS NOT NULL GROUP BY {0}\",\n \"\\\"\\\"\\\" --------------------------------------------------------------------------- Divides the vColumn by the input element. Parameters\",\n \"to plot on. **style_kwds Any optional parameter to pass to\",\n \"the vColumn using 'kurtosis'. Returns ------- float kurtosis See Also\",\n \"using 'median'. Parameters ---------- approx: bool, optional If set to\",\n \"tuple] = (6, 6), h: Union[int, float, tuple] = (None,\",\n \"the optimal h. auto : Combination of Freedman Diaconis and\",\n \"FROM vdf_table WHERE {} > {})\\\".format( self.parent.__genSQL__(), self.alias, self.alias, p_alpha,\",\n \"not be empty\\\" ) assert not (self.parent.is_colname_in(name)), NameError( f\\\"A vColumn\",\n \"NOT NULL\\\".format(self.alias)) return self.parent # ---# def fill_outliers( self, method:\",\n \"and other statistical information. Parameters ---------- k: int, optional Number\",\n \"more information, see utilities.tablesample. See Also -------- vDataFrame[].head : Returns\",\n \")[self.alias].density( bandwidth=bandwidth, kernel=kernel, nbins=nbins, xlim=(xmin, xmax), ax=ax, **updated_dict(param, style_kwds, idx),\",\n \"== \\\"minmax\\\": if n == 0: nullifzero = 0 cmin,\",\n \"= \\\"SELECT {}::{} AS {} FROM {} WHERE {} IS\",\n \"\\\"count\\\": [int(item[1]) for item in result], \\\"percent\\\": [float(round(item[2], 3)) for\",\n \"* ## # # __ __ ______ ______ __ __\",\n \"GROUP BY {}\\\".format( by[0], self.alias, self.alias, self.parent.__genSQL__(), by[0], ), title=\\\"Computing\",\n \"---# def __repr__(self): return self.head(limit=verticapy.options[\\\"max_rows\\\"]).__repr__() # ---# def _repr_html_(self): return\",\n \"vColumn. nbins: int, optional Maximum number of nbins used for\",\n \"Offset. Returns ------- tablesample An object containing the result. For\",\n \"the input method. Parameters ---------- method: str, optional Method to\",\n \"Returns True if the vColumn is numerical, False otherwise. Returns\",\n \"be a list of at least one element to use\",\n \") except: pass total = int(total) conj = \\\"s were\",\n \"self.parent # ---# def aggregate(self, func: list): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates\",\n \"p_alpha, p_1_alpha, \\\"{}\\\" ) ) elif method == \\\"mean\\\": query\",\n \"--------------------------------------------------------------------------- Filters the vDataFrame where the vColumn is missing. Returns\",\n \"\\\"method\\\", method, [\\\"auto\\\", \\\"smart\\\", \\\"same_width\\\", \\\"same_freq\\\", \\\"topk\\\"], ), (\\\"return_enum_trans\\\", return_enum_trans,\",\n \"result = [elem[0] for elem in result] except: drop(tmp_view_name, method=\\\"view\\\")\",\n \"during the computation. n: int, optional Integer corresponding to the\",\n \"result[4], result[6], result[7], ) elif self.isdate(): min_date = self.min() table\",\n \"topk, ) result = executeSQL( query, title=\\\"Computing the top{} categories\",\n \"val = val.replace(\\\"'\\\", \\\"''\\\") if val != None: new_column =\",\n \"element from the vColumn. Parameters ---------- x: float If the\",\n \"vDataFrame.aggregate : Computes the vDataFrame input aggregations. \\\"\\\"\\\" return self.aggregate([\\\"mad\\\"]).values[self.alias][0]\",\n \"[cat_priority] check_types( [ (\\\"by\\\", by, [str]), (\\\"max_cardinality\\\", max_cardinality, [int, float]),\",\n \"+= [str(total)] total += nb where = \\\"WHERE _verticapy_row_nb_ IN\",\n \"The integer k of the 'topk' method. new_category: str, optional\",\n \"non_events = 0 OR events = 0 THEN 0 ELSE\",\n \"method.lower() assert (method != \\\"cat_stats\\\") or (numcol), ParameterError( \\\"The parameter\",\n \"title=\\\"Computing the descriptive statistics of {}.\\\".format(self.alias), method=\\\"fetchall\\\", ) result =\",\n \"(PARTITION BY {}))\\\".format( \\\"{}\\\", fun, \\\"{}\\\", \\\", \\\".join(by) ) else:\",\n \"by[0], self.alias, self.alias, self.parent.__genSQL__(), by[0], ), title=\\\"Computing the different categories\",\n \"def skewness(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using 'skewness'. Returns\",\n \"\\\" WHERE {} = '{}'\\\".format( bin_spatial_to_str(self.category(), self.alias), category, ) )\",\n \"\\\"\\\"\\\" check_types([(\\\"response\\\", response, [str])]) self.parent.are_namecols_in(response) response = self.parent.format_colnames(response) assert self.parent[response].isnum(),\",\n \"not (dropna) and (pre_comp != None): return pre_comp assert n\",\n \"when applying the func 'x -> {}' to '{}'\\\".format( e,\",\n \"= [], order_by: list = [], ): \\\"\\\"\\\" --------------------------------------------------------------------------- Fills\",\n \"{})\\\".format(x, \\\"{}\\\")) else: return self.apply(func=\\\"{} + ({})\\\".format(\\\"{}\\\", x)) # ---#\",\n \"Random Forest model parameters used to compute the best splits\",\n \"# ---# def topk(self, k: int = -1, dropna: bool\",\n \"self.alias, self.parent.__genSQL__() ) query = \\\"SELECT COUNT({}) AS NAs, MIN({})\",\n \"Back Propagation of the next element (Constant Interpolation). ffill :\",\n \"\\\" END\\\" self.apply(func=expr) # ---# def ctype(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns\",\n \"+ [item[1] for item in query_result] index = [\\\"unique\\\", \\\"count\\\"]\",\n \"more information, see utilities.tablesample. See Also -------- vDataFrame.iv_woe : Computes\",\n \") warnings.warn(warning_message, Warning) return self elif (n == 1) and\",\n \"times, so it's better practice to use this method when\",\n \"== \\\"minmax\\\": self.catalog[elem] = (sauv[elem] - sauv[\\\"min\\\"]) / ( sauv[\\\"max\\\"]\",\n \"/ / # |____/ / / # _____________ / /\",\n \"comma. Parameters ---------- n: int Number of digits to keep\",\n \"from collections.abc import Iterable from typing import Union # VerticaPy\",\n \"in the vColumn and it returns the new vDataFrame of\",\n \"stddev = ( \\\"AVG({}) OVER (PARTITION BY {})\\\".format( self.alias, \\\",\",\n \"datetime.date] = \\\"\\\", end_date: Union[str, datetime.datetime, datetime.date] = \\\"\\\", area:\",\n \"float]), (\\\"cat_priority\\\", cat_priority, [list]), ] ) if by: self.parent.are_namecols_in(by) by\",\n \"the dummies. drop_first: bool, optional Drops the first dummy to\",\n \"{} ORDER BY _verticapy_cnt_ DESC {}\\\".format( bin_spatial_to_str(self.category(), self.alias), self.alias, self.parent.shape()[0],\",\n \"be transformed. Parameters ---------- pat: str Regular expression. Returns -------\",\n \"= get_category_from_vertica_type(ctype=ctype) all_cols, max_floor = self.parent.get_columns(), 0 for column in\",\n \"events = 0 THEN 0 ELSE ZEROIFNULL(LN(pt_non_events / NULLIFZERO(pt_events))) END\",\n \"float var See Also -------- vDataFrame.aggregate : Computes the vDataFrame\",\n \"of the different transformations. \\\"\\\"\\\" # # Special Methods #\",\n \"the second argument. Returns ------- vDataFrame self.parent See Also --------\",\n \"return tail # ---# def isbool(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns True\",\n \"int Slice size. unit: str, optional Slice size unit. For\",\n \"an input value. \\\"\\\"\\\" check_types([(\\\"start\\\", start, [int, float]), (\\\"step\\\", step,\",\n \"def round(self, n: int): \\\"\\\"\\\" --------------------------------------------------------------------------- Rounds the vColumn by\",\n \"= \\\"zscore\\\", by: list = [], return_trans: bool = False\",\n \"h: float, optional Interval width if the vColumn is numerical\",\n \"on the right. Returns ------- vDataFrame self.parent See Also --------\",\n \"\\\"]\\\" else: op1, op2, close_l, close_r = \\\"<=\\\", \\\"<\\\", \\\"[\\\",\",\n \"str = \\\"\\\", by: list = [], order_by: list =\",\n \"function to the vColumn. \\\"\\\"\\\" check_types( [ ( \\\"func\\\", func,\",\n \"nbins, h, ax=ax, **style_kwds) # ---# def boxplot( self, by:\",\n \"\\\"\\\", max_cardinality: int = 6, h: float = 0, pie_type:\",\n \"top # ---# def mul(self, x: float): \\\"\\\"\\\" --------------------------------------------------------------------------- Multiplies\",\n \") ) # ---# def spider( self, by: str =\",\n \"< {} THEN {} \\\".format(\\\"{}\\\", lower, lower) if (isinstance(lower, (float,\",\n \"outliers by the NULL value. winsorize : Clips the vColumn\",\n \"elem in copy_trans] for elem in sauv: self.catalog[elem] = sauv[elem]\",\n \"str, transformations: list = [], parent=None, catalog: dict = {}\",\n \"title=\\\"Computing the equal frequency histogram bins.\\\", method=\\\"fetchall\\\", ) result =\",\n \"{} BETWEEN {} AND {} THEN '[{};{}]' \\\".format( \\\"{}\\\", result[i\",\n \"method = method.lower() self.parent.are_namecols_in([elem for elem in order_by] + by)\",\n \"--------------------------------------------------------------------------- Aggregates the vColumn using 'min' (Minimum). Returns ------- float/str\",\n \"# ---# def nunique(self, approx: bool = True): \\\"\\\"\\\" ---------------------------------------------------------------------------\",\n \"!= None ] ), ) stddev = \\\"DECODE({}, {}, NULL)\\\".format(\",\n \"from verticapy.plot import range_curve_vdf return range_curve_vdf( self, ts, q, start_date,\",\n \"] self.parent.__update_catalog__(erase=True, columns=[self.alias]) self.parent.__add_to_history__( \\\"[Mean Encode]: The vColumn {} was\",\n \"\\\"int\\\": best_h = max(math.floor(best_h), 1) return best_h # ---# def\",\n \"not in kwargs: query = \\\"SELECT {} AS {} FROM\",\n \"DB version you are using. Returns ------- tablesample An object\",\n \"( \\\"(CASE WHEN {} IN ({}) THEN {} || ''\",\n \"tuple, optional Tuple including the 2 quantiles used to draw\",\n \"elem in order_by] for elem in all_partition: if len(self.parent[elem].transformations) >\",\n \"------- int number of non-Missing elements. See Also -------- vDataFrame.aggregate\",\n \"Computes the vDataFrame input aggregations. \\\"\\\"\\\" return self.aggregate([\\\"sem\\\"]).values[self.alias][0] # ---#\",\n \"vDataFrame[].ctype : Returns the vColumn database type. \\\"\\\"\\\" return self.transformations[-1][2]\",\n \"*= 1.4826 if mad != 0: if return_trans: return \\\"({}\",\n \"stddev ), \\\"float\\\", \\\"float\\\", ) ] elif method == \\\"robust_zscore\\\":\",\n \"= (sauv[elem] - sauv[\\\"approx_50%\\\"]) / ( 1.4826 * sauv[\\\"mad\\\"] )\",\n \"k > 0 else \\\"\\\", self.alias ), method=\\\"fetchall\\\", ) values\",\n \"a new vColumn to the vDataFrame by using an advanced\",\n \"[bool]), ] ) method = method.lower() self.parent.are_namecols_in(by) by = self.parent.format_colnames(by)\",\n \"= '03-11-1993' will filter the data when 'ts' is greater\",\n \"by an input value. The vColumn will be transformed. Parameters\",\n \"vColumn category. In this case, the parameter 'numcol' must be\",\n \"self.catalog: sauv[elem] = self.catalog[elem] self.parent.__update_catalog__(erase=True, columns=[self.alias]) total = abs(self.count() -\",\n \"considered as categorical. numcol: str, optional Numerical vColumn to use\",\n \"---------- response: str Response vColumn. Returns ------- vDataFrame self.parent See\",\n \"int, optional Maximum number of vColumn distinct elements to be\",\n \"COUNT(*) / {} AS percent FROM {}{} GROUP BY {}\",\n \"when 'ts' is greater than November 1993 the 3rd. plot_median:\",\n \"self.alias, topk, ) result = executeSQL( query, title=\\\"Computing the top{}\",\n \"be included. right: bool, optional How the intervals should be\",\n \"missing values. auto : Mean for the numerical and Mode\",\n \"elif isinstance(index, int): cast = \\\"::float\\\" if self.category() == \\\"float\\\"\",\n \"[CEIL(log2(n)) + 1] Returns ------- float optimal bar width. \\\"\\\"\\\"\",\n \"{op2} '{second_elem}' THEN '{label}'\\\" ] expr = \\\"CASE WHEN \\\"\",\n \"merge the other into one unique category. h: float, optional\",\n \"be filled. Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].drop_outliers\",\n \"\\\"It can be the result of using previously the method\",\n \"if n == 1: pre_comp = self.parent.__get_catalog_value__(self.alias, \\\"top\\\") if pre_comp\",\n \"in the partition. return_trans: bool, optimal If set to True,\",\n \"average absolute deviation approx_unique : approximative cardinality count : number\",\n \"[bool]), ] ) start_or_end = \\\"START\\\" if (start) else \\\"END\\\"\",\n \"OFFSET {}\\\".format( bin_spatial_to_str(self.category(), self.alias), self.alias, self.parent.__genSQL__(), self.parent.__get_last_order_by__(), limit, offset, ),\",\n \") # ---# def str_count(self, pat: str): \\\"\\\"\\\" --------------------------------------------------------------------------- Computes\",\n \"percent : percent of non-missing elements q% : q quantile\",\n \"see utilities.tablesample. See Also -------- vDataFrame[].nlargest : Returns the n\",\n \"{}'s lower and upper outliers.\\\".format( self.alias ), method=\\\"fetchall\\\", ) ]\",\n \"percentile = 0.1) AS 'approx_10%', APPROXIMATE_PERCENTILE ({3}{4} USING PARAMETERS percentile\",\n \"computed. pie_type: str, optional The type of pie chart. auto\",\n \"{})\\\".format(\\\"{}\\\", start, step)) # ---# def sub(self, x: float): \\\"\\\"\\\"\",\n \"[distinct_count, self.count()] + [item[1] for item in query_result] index =\",\n \"Returns the vColumn most occurent elements. \\\"\\\"\\\" if \\\"agg\\\" not\",\n \"If set to True, the approximate cardinality is returned. By\",\n \"limit: int = 5): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns the head of\",\n \": Back Propagation of the next element (Constant Interpolation). ffill\",\n \"---------- func: str, Function in pure SQL used to transform\",\n \"{}'.\\\".format( copy_name.replace('\\\"', \\\"\\\"), func.replace(\\\"{}\\\", \\\"x\\\"), ) ) else: for k\",\n \"verticapy.errors import * ## # # __ __ ______ ______\",\n \"Computes the vDataFrame input aggregations. \\\"\\\"\\\" return self.aggregate([\\\"mad\\\"]).values[self.alias][0] # ---#\",\n \"expression in each record of the vColumn. vDataFrame[].str_slice : Slices\",\n \"If set to True, NULL values will not be considered\",\n \") assert len(breaks) >= 2, ParameterError( \\\"Length of parameter 'breaks'\",\n \"---------- val: int/float/str, optional Value to use to impute the\",\n \"self.category() in [\\\"date\\\", \\\"float\\\"]: warning_message = ( \\\"label_encode is only\",\n \"6) else \\\"mode\\\" total = self.count() if (method == \\\"mode\\\")\",\n \"quantile (or approximate quantile). See Also -------- vDataFrame.aggregate : Computes\",\n \"{} WHERE {} IS NOT NULL GROUP BY {} ORDER\",\n \"val += list(args) check_types([(\\\"val\\\", val, [list])]) val = {self.alias: val}\",\n \": Sturges [CEIL(log2(n)) + 1] Returns ------- float optimal bar\",\n \"--------------------------------------------------------------------------- Aggregates the vColumn using the input functions. Parameters ----------\",\n \"normalize.\\\", method=\\\"fetchall\\\", ) for i in range(len(result)): if result[i][2] ==\",\n \"IS NOT NULL \\\".format(self.alias) if (dropna) else \\\" \\\" result\",\n \"if (nullifzero) else \\\"\\\", stddev ) else: final_transformation = [\",\n \"self.alias, self.parent.__genSQL__(), self.parent.__get_last_order_by__(), limit, offset, ), title=title, ) tail.count =\",\n \"of the vColumn 'of'. max : Maximum of the vColumn\",\n \"item in sublist] # ---# def div(self, x: float): \\\"\\\"\\\"\",\n \"get_dummies # ---# def head(self, limit: int = 5): \\\"\\\"\\\"\",\n \"elem[0] != None else \\\"NULL\\\", elem[1] if elem[1] != None\",\n \"new vDataFrame of the search. Parameters ---------- val: list List\",\n \") query = \\\"SELECT {}, MIN(ord) AS ord, SUM(1 -\",\n \"bool True if the vColumn is numerical. See Also --------\",\n \"non_events, events, pt_non_events, pt_events, CASE WHEN non_events = 0 OR\",\n \"---# def drop_outliers( self, threshold: float = 4.0, use_threshold: bool\",\n \"0.75) AS Q3, MAX({}) AS max FROM {}\\\".format( self.alias, self.alias,\",\n \"# ---# def __repr__(self): return self.head(limit=verticapy.options[\\\"max_rows\\\"]).__repr__() # ---# def _repr_html_(self):\",\n \"categories to [0, n - 1] (n being the vColumn\",\n \"category = get_category_from_vertica_type(ctype=ctype) all_cols, max_floor = self.parent.get_columns(), 0 for column\",\n \"be computed. ax: Matplotlib axes object, optional The axes to\",\n \"vColumn elements. Parameters ---------- n: int, optional Offset. Returns -------\",\n \"vDataFrame[].str_contains : Verifies if the regular expression is in each\",\n \"include_lowest, [bool]), (\\\"right\\\", right, [bool]), ] ) assert self.isnum() or\",\n \"\\\"\\\"\\\" if isinstance(cat_priority, str) or not (isinstance(cat_priority, Iterable)): cat_priority =\",\n \"optimized h will be computed. pie_type: str, optional The type\",\n \"= True): \\\"\\\"\\\" --------------------------------------------------------------------------- Drops the vColumn from the vDataFrame.\",\n \"{}\\\".format(k) dropna = \\\" WHERE {} IS NOT NULL\\\".format(self.alias) if\",\n \"not (dropna): n = \\\"\\\" if (n == 1) else\",\n \"result. For more information, see utilities.tablesample. See Also -------- vDataFrame[].nlargest\",\n \"self.add_copy(new_name) parent = self.drop(add_history=False) parent.__add_to_history__( \\\"[Rename]: The vColumn {} was\",\n \"each of the vColumn records. The vColumn will be transformed.\",\n \"p_alpha, mean_alpha, \\\"{}\\\", p_1_alpha, mean_1_alpha, \\\"{}\\\" ) ) return self.parent\",\n \"3)) for item in result], } return tablesample(values) # ---#\",\n \"- sauv[\\\"min\\\"] ) except: pass if method == \\\"robust_zscore\\\": self.catalog[\\\"median\\\"]\",\n \"by: self.parent.are_namecols_in(by) by = self.parent.format_colnames(by) columns = [self.alias, by] else:\",\n \": interquartile range kurtosis : kurtosis jb : Jarque-Bera index\",\n \"VERTICAPY_SUBTABLE WHERE split_value IS NOT NULL GROUP BY 1 ORDER\",\n \"ANY KIND, either express or implied. # See the License\",\n \"the discretization (must be > 1) Returns ------- tablesample An\",\n \"func, [ \\\"abs\\\", \\\"acos\\\", \\\"asin\\\", \\\"atan\\\", \\\"cbrt\\\", \\\"ceil\\\", \\\"cos\\\", \\\"cosh\\\",\",\n \"# See the License for the specific language governing permissions\",\n \"by == []: if fun == \\\"AVG\\\": val = self.avg()\",\n \"n: int = 1): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns the nth most\",\n \"{} FROM {}) VERTICAPY_OPTIMAL_H_TABLE\\\".format( min_date, self.alias, self.alias, self.parent.__genSQL__() ) query\",\n \"memory usage. \\\"\\\"\\\" import sys total = ( sys.getsizeof(self) +\",\n \"elem in copy_trans] raise QueryError(\\\"{}\\\\nAn Error happened during the filling.\\\".format(e))\",\n \"else: model = RandomForestClassifier(tmp_model_name) model.set_params({\\\"n_estimators\\\": 20, \\\"max_depth\\\": 8, \\\"nbins\\\": 100})\",\n \"computed aggregations to gain in performance. The catalog will be\",\n \"------- float quantile (or approximate quantile). See Also -------- vDataFrame.aggregate\",\n \"different categories to consider when drawing the box plot. The\",\n \"(schema): schema = \\\"public\\\" tmp_view_name = gen_tmp_name(schema=schema, name=\\\"view\\\") tmp_model_name =\",\n \"The vColumn type must be date like (date, datetime, timestamp...)\",\n \"used in the partition. order_by: list, optional List of the\",\n \"optional SQL expression. by: list, optional vColumns used in the\",\n \"not (self.parent.is_colname_in(name)), NameError( f\\\"A vColumn has already the alias {name}.\\\\nBy\",\n \"'numcol' must be defined. numerical : Uses popular numerical aggregations\",\n \"cmax, cmin, ) else: final_transformation = [ ( \\\"({} -\",\n \"nbins: int, optional Number of bins. If empty, an optimized\",\n \"the number of seconds, otherwise it will represent a number.\",\n \"'of'. q% : q Quantile of the vColumn 'of' (ex:\",\n \"isinstance(index, slice): assert index.step in (1, None), ValueError( \\\"vColumn doesn't\",\n \"isinstance(val, str): val = val.replace(\\\"'\\\", \\\"''\\\") if val != None:\",\n \"/ / # / / # / / # \\\\\",\n \"points to use to evaluate the approximate density function. Increasing\",\n \"optional Method to use to fill the vColumn outliers. mean\",\n \"Uses numbers as suffix instead of the vColumns categories. Returns\",\n \">= 1, ParameterError(\\\"Parameter 'n' must be greater or equal to\",\n \"\\\"\\\"\\\" check_types([(\\\"n\\\", n, [int, float])]) query = \\\"SELECT * FROM\",\n \"(\\\"step\\\", step, [bool]), ] ) self.parent.are_namecols_in(ts) ts = self.parent.format_colnames(ts) if\",\n \"\\\"donut\\\", \\\"rose\\\"]), ] ) donut = True if pie_type ==\",\n \"[str])]) try: query = \\\"SELECT {}::{} AS {} FROM {}\",\n \"bin_spatial_to_str(self.category(), self.alias), category, ) ) query += [lp + tmp_query\",\n \"time series. \\\"\\\"\\\" check_types( [ (\\\"ts\\\", ts, [str]), (\\\"by\\\", by,\",\n \"suffix instead of the vColumns categories. Returns ------- vDataFrame self.parent\",\n \"\\\"\\\" ) func = \\\"(CASE {}{}ELSE {} END)\\\".format(lower_when, upper_when, \\\"{}\\\")\",\n \"/ {}({})\\\".format( self.alias, avg, \\\"NULLIFZERO\\\" if (nullifzero) else \\\"\\\", stddev\",\n \"a number. Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].apply\",\n \"absolute value of the record is greater than the threshold,\",\n \"the vColumns 1 and 2 bars. It is only valid\",\n \": Applies a function to the input vColumn. \\\"\\\"\\\" check_types([(\\\"x\\\",\",\n \"See Also -------- vDataFrame.astype : Converts the vColumns to the\",\n \"approx, [bool]))]) prefix = \\\"approx_\\\" if approx else \\\"\\\" return\",\n \"check_types([(\\\"x\\\", x, [int, float])]) if self.isdate(): return self.apply(func=\\\"TIMESTAMPADD(SECOND, {}, {})\\\".format(x,\",\n \"to define the outliers. After normalizing the data (Z-Score), if\",\n \"other types to varchar. same_freq : Computes bins with the\",\n \"a new vColumn labeled with 0 and 1 (1 meaning\",\n \"set to False else the lower and upper ZScores. threshold:\",\n \"elem in transformations], ) self.catalog = { \\\"cov\\\": {}, \\\"pearson\\\":\",\n \"during the filling.\\\".format(e)) if total > 0: try: if \\\"count\\\"\",\n \"\\\".join([\\\"1\\\"] + nth_elems + [str(count)]) ) query = \\\"SELECT {}\",\n \"The vColumn to use to compute the aggregation. h: int/float/tuple,\",\n \"---------- method: str, optional Method to use to fill the\",\n \"Draws the range plot of the vColumn. The aggregations used\",\n \"end_date: str / date, optional Input End Date. For example,\",\n \"better practice to use this method when first preparing your\",\n \"True): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using 'unique' (cardinality). Parameters\",\n \"Licensed under the Apache License, Version 2.0 (the \\\"License\\\"); #\",\n \"by an input value. vDataFrame[].str_slice : Slices the vColumn. \\\"\\\"\\\"\",\n \"(IV) / Weight Of Evidence (WOE) Table. It tells the\",\n \"elif (n == 1) and (self.parent[by[0]].nunique() < 50): try: result\",\n \"slice(self, length: int, unit: str = \\\"second\\\", start: bool =\",\n \"idea is simple: instead of moving # data around for\",\n \"Parameters ---------- alias: str vColumn alias. transformations: list, optional List\",\n \"optional The name of the merging category when using the\",\n \"\\\"[Drop]: vColumn {} was deleted from the vDataFrame.\\\".format(self.alias) ) return\",\n \"\\\"pearson\\\": {}, \\\"spearman\\\": {}, \\\"spearmand\\\": {}, \\\"kendall\\\": {}, \\\"cramer\\\": {},\",\n \"name the new categories. If empty, names will be generated.\",\n \"max(0, self.parent.shape()[0] - limit) title = \\\"Reads {}.\\\".format(self.alias) tail =\",\n \"than 1.\\\" ) index_stop = index.stop index_start = index.start if\",\n \"else \\\"\\\" query, cat = [], self.distinct() if len(cat) ==\",\n \"vDataFrame input aggregations. \\\"\\\"\\\" check_types([(\\\"approx\\\", approx, [bool])]) if approx: return\",\n \"[int, float])]) if self.isdate(): return self.apply(func=\\\"TIMESTAMPADD(SECOND, {}, {})\\\".format(x, \\\"{}\\\")) else:\",\n \"elements to display. Returns ------- tablesample An object containing the\",\n \"record of the vColumn. vDataFrame[].str_replace : Replaces the regular expression\",\n \"+ 1] Returns ------- float optimal bar width. \\\"\\\"\\\" check_types(\",\n \"model parameters used to compute the best splits when 'method'\",\n \"total) / self.parent.shape()[0] ) except: pass total = int(total) conj\",\n \"by their respective average. null : Replaces the outliers by\",\n \"else \\\"\\\", stddev ) else: final_transformation = [ ( \\\"({}\",\n \"[bool]), ] ) distinct_elements = self.distinct() if distinct_elements not in\",\n \"2)), 1e-99, ) fd = max(2.0 * (vColumn_075 - vColumn_025)\",\n \"MAD is null !\\\".format( self.alias ) warnings.warn(warning_message, Warning) return self\",\n \"to the geopandas plot function. For more information, see: https://geopandas.readthedocs.io/en/latest/docs/reference/api/\",\n \"---# def apply(self, func: str, copy_name: str = \\\"\\\"): \\\"\\\"\\\"\",\n \"the vColumn 'of'. min : Minimum of the vColumn 'of'.\",\n \"elements. same_width : Computes regular width bins. smart : Uses\",\n \"name = ( name.replace(\\\" \\\", \\\"_\\\") .replace(\\\"/\\\", \\\"_\\\") .replace(\\\",\\\", \\\"_\\\")\",\n \"optional Cardinality threshold to use to determine if the vColumn\",\n \"Median will be drawn. ax: Matplotlib axes object, optional The\",\n \"1.4826 * sauv[\\\"mad\\\"] ) elif method == \\\"zscore\\\": self.catalog[elem] =\",\n \"of bins will be computed. h: float, optional Interval width\",\n \"schema = verticapy.options[\\\"temp_schema\\\"] if not (schema): schema = \\\"public\\\" tmp_view_name\",\n \"**style_kwds, ): \\\"\\\"\\\" --------------------------------------------------------------------------- Draws the spider plot of the\",\n \"of the DB version you are using. Returns ------- tablesample\",\n \"pie_type = pie_type.lower() check_types( [ (\\\"method\\\", method, [str]), (\\\"of\\\", of,\",\n \"\\\"SELECT * FROM {} WHERE {} IS NOT NULL ORDER\",\n \"1) return best_h # ---# def nunique(self, approx: bool =\",\n \"x, [int, float]), ] ) if func not in (\\\"log\\\",\",\n \"---# def sum(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using 'sum'.\",\n \"method 'same_width' for numerical vColumns, cast the other types to\",\n \"), \\\"STDDEV({}) OVER (PARTITION BY {})\\\".format( self.alias, \\\", \\\".join(by) ),\",\n \"if drop_first else 0 for k in range(len(distinct_elements) - n):\",\n \"= 1 then this method will return the mode of\",\n \"\\\"APPROXIMATE_MEDIAN\\\" query = \\\"SELECT {}, {}({}) FROM {} GROUP BY\",\n \"---# def nsmallest(self, n: int = 10): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns\",\n \"input aggregations. \\\"\\\"\\\" return self.aggregate([\\\"max\\\"]).values[self.alias][0] # ---# def mean_encode(self, response:\",\n \"to {}\\\".format( e, self.alias, dtype ) ) # ---# def\",\n \"TIMEZONE_HOUR / TIMEZONE_MINUTE / WEEK / YEAR Returns ------- vDataFrame\",\n \"method == \\\"smart\\\": schema = verticapy.options[\\\"temp_schema\\\"] if not (schema): schema\",\n \"0 ] # ---# def range_plot( self, ts: str, q:\",\n \"else str(elem[1]) new_column = \\\"COALESCE({}, DECODE({}, {}, NULL))\\\".format( \\\"{}\\\", by[0],\",\n \"The vColumn '{}' was transformed with the func 'x ->\",\n \"'prefix_sep'), you'll be able to solve this \\\" \\\"issue.\\\" )\",\n \"k in range(max_floor): self.transformations += [(\\\"{}\\\", self.ctype(), self.category())] self.transformations +=\",\n \"+= self.parent.shape()[0] query = \\\"SELECT {}{} FROM {}{} OFFSET {}\",\n \"# ---# def __setattr__(self, attr, val): self.__dict__[attr] = val #\",\n \"TIMEZONE_MINUTE / WEEK / YEAR Returns ------- vDataFrame self.parent See\",\n \"by] else: columns = [self.alias] if of: self.parent.are_namecols_in(of) of =\",\n \"): \\\"\\\"\\\" --------------------------------------------------------------------------- Draws the bar chart of the vColumn\",\n \"list = [], parent=None, catalog: dict = {} ): self.parent,\",\n \"# ---# def bar( self, method: str = \\\"density\\\", of:\",\n \"unique... depending on the input method. Parameters ---------- method: str,\",\n \"sauv[elem] = self.catalog[elem] self.parent.__update_catalog__(erase=True, columns=[self.alias]) total = abs(self.count() - total)\",\n \"---# def sub(self, x: float): \\\"\\\"\\\" --------------------------------------------------------------------------- Subtracts the input\",\n \"and method == \\\"smart\\\" ): n = len(result) trans =\",\n \": mode (most occurent element). 0ifnull : 0 when the\",\n \") result = executeSQL( query, title=\\\"Computing the top{} categories of\",\n \"Also -------- vDataFrame.filter: Filters the data using the input expression.\",\n \"BY COUNT(*) DESC LIMIT {1})\\\"\\\"\\\".format( self.alias, max_cardinality ) if distinct_count\",\n \"[\\\"\\\"] result.values[\\\"iv\\\"] += [sum(result[\\\"iv\\\"])] return result # ---# def kurtosis(self):\",\n \"/\\\\ \\\\ / / /\\\\ ___\\\\ /\\\\ __ \\\\ /\\\\\",\n \"see utilities.tablesample. See Also -------- vDataFrame[].nsmallest : Returns the n\",\n \"else \\\" was \\\" if verticapy.options[\\\"print_info\\\"]: print(\\\"{} element{}filled.\\\".format(total, conj)) self.parent.__add_to_history__(\",\n \"(SELECT COUNT(*) AS count\\\" \\\" FROM vdf_table WHERE {0} IS\",\n \"of the vColumn records by an input value. \\\"\\\"\\\" check_types([(\\\"start\\\",\",\n \"-------- vDataFrame[].bar : Draws the Bar Chart of vColumn based\",\n \"None): val = self.mode(dropna=True) if val == None: warning_message =\",\n \"import verticapy from verticapy.utilities import * from verticapy.toolbox import *\",\n \"optional Number of most occurent elements to return. Returns -------\",\n \"str = \\\"Others\\\", RFmodel_params: dict = {}, response: str =\",\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,\",\n \"str, optional The method to use to aggregate the data.\",\n \"{})\\\".format( self.alias, cmin, \\\"NULLIFZERO\\\" if (nullifzero) else \\\"\\\", cmax, cmin,\",\n \"non-Missing elements. See Also -------- vDataFrame.aggregate : Computes the vDataFrame\",\n \"ParameterError( \\\"Parameter 'response' can not be empty in case of\",\n \"the other into one unique category. h: float, optional The\",\n \"{}, NULL)\\\".format( by[0], \\\", \\\".join( [ \\\"{}, {}\\\".format( \\\"'{}'\\\".format(str(elem[0]).replace(\\\"'\\\", \\\"''\\\"))\",\n \".values[self.alias] ) self.parent.filter( \\\"({} BETWEEN {} AND {})\\\".format(self.alias, p_alpha, p_1_alpha)\",\n \"cmax, cmin, ), \\\"float\\\", \\\"float\\\", ) ] if method !=\",\n \"= executeSQL( \\\"SELECT ZEROIFNULL(SUM(LENGTH({}::varchar))) FROM {}\\\".format( bin_spatial_to_str(self.category(), self.alias), self.parent.__genSQL__(), ),\",\n \"True if the vColumn is boolean. vDataFrame[].isdate : Returns True\",\n \"IV of {} (response = {}).\\\".format(self.alias, y) result = to_tablesample(query,\",\n \"CASE WHEN non_events = 0 OR events = 0 THEN\",\n \"if isinstance(method, str): method = method.lower() check_types( [ (\\\"method\\\", method,\",\n \"\\\"tan\\\", \\\"tanh\\\", ], ), (\\\"x\\\", x, [int, float]), ] )\",\n \"\\\"int\\\"), TypeError( \\\"The column 'numcol' must be numerical\\\" ) cast\",\n \"of the input vColumns based on an aggregation. \\\"\\\"\\\" check_types(\",\n \"result.values[\\\"events\\\"] += [sum(result[\\\"events\\\"])] result.values[\\\"pt_non_events\\\"] += [\\\"\\\"] result.values[\\\"pt_events\\\"] += [\\\"\\\"] result.values[\\\"woe\\\"]\",\n \"offset < 0: offset = max(0, self.parent.shape()[0] - limit) title\",\n \"/ NULLIFZERO(pt_events))) END AS iv FROM ({}) x ORDER BY\",\n \"the vColumn using 'std' (Standard Deviation). Returns ------- float std\",\n \"if self.isdate(): return self.apply(func=\\\"TIMESTAMPADD(SECOND, {}, {})\\\".format(x, \\\"{}\\\")) else: return self.apply(func=\\\"{}\",\n \"str = \\\"\\\"): \\\"\\\"\\\" --------------------------------------------------------------------------- Replaces the regular expression matches\",\n \"\\\"0ifnull\\\", \\\"mean\\\", \\\"avg\\\", \\\"median\\\", \\\"ffill\\\", \\\"pad\\\", \\\"bfill\\\", \\\"backfill\\\", ], ),\",\n \": kurtosis jb : Jarque-Bera index mad : median absolute\",\n \"# \\\\ \\\\ \\\\'/ \\\\ \\\\ \\\\____ \\\\ \\\\ \\\\/\\\\\",\n \"if some specific records are in the vColumn and it\",\n \"and as upper bound quantile(1-alpha) if 'use_threshold' is set to\",\n \"3)] sturges : Sturges [CEIL(log2(n)) + 1] Returns ------- float\",\n \"): self.parent, self.alias, self.transformations = ( parent, alias, [elem for\",\n \"== \\\"same_freq\\\": assert nbins >= 2, ParameterError( \\\"Parameter 'nbins' must\",\n \"{} must be binary to use iv_woe.\\\".format(y) ) self.parent[y].distinct() trans\",\n \"often they occur, and other statistical information. Parameters ---------- k:\",\n \"\\\"fd\\\"): best_h = fd else: best_h = max(sturges, fd) self.parent.__update_catalog__({\\\"index\\\":\",\n \"less frequent elements will be gathered together to create a\",\n \"( result[0], result[3], result[4], result[6], result[7], ) elif self.isdate(): min_date\",\n \"parameters ('prefix', 'prefix_sep'), you'll be able to solve this \\\"\",\n \"max_cardinality, h, ax=ax, **style_kwds, ) # ---# def std(self): \\\"\\\"\\\"\",\n \"having steps different than 1.\\\" ) index_stop = index.stop index_start\",\n \"and (pre_comp != None): return pre_comp assert n >= 1,\",\n \"{}, ord, non_events, events, non_events / NULLIFZERO(SUM(non_events) OVER ()) AS\",\n \"clip(self, lower=None, upper=None): \\\"\\\"\\\" --------------------------------------------------------------------------- Clips the vColumn by transforming\",\n \"\\\"(SELECT READ_TREE(USING PARAMETERS model_name = '{}', tree_id = {}, format\",\n \"# ---# def distinct(self, **kwargs): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns the distinct\",\n \"if (elem[1] == None) else str(elem[1]) new_column = \\\"COALESCE({}, DECODE({},\",\n \"= self.max() else: xmin, xmax = xlim custom_lines = []\",\n \"smart : Uses the Random Forest on a response column\",\n \"vDataFrame[].decode : Encodes the vColumn with user defined Encoding. vDataFrame[].get_dummies\",\n \"= \\\"SELECT {} FROM (SELECT {}, ROW_NUMBER() OVER (ORDER BY\",\n \"parent = self.parent force_columns = [ column for column in\",\n \"the vColumn to the input type. Parameters ---------- dtype: str\",\n \"h: int/float/tuple, optional Interval width of the vColumns 1 and\",\n \"1: try: result = executeSQL( \\\"SELECT {}, MIN({}), MAX({}) FROM\",\n \"({})\\\".format(\\\"{}\\\", med, mad), \\\"float\\\", \\\"float\\\", ) ] else: warning_message =\",\n \"= \\\"START\\\" if (start) else \\\"END\\\" return self.apply( func=\\\"TIME_SLICE({}, {},\",\n \": kth most occurent element (ex: top1 for the mode)\",\n \"self.ctype().lower() in (\\\"bool\\\", \\\"boolean\\\") # ---# def isdate(self): \\\"\\\"\\\" ---------------------------------------------------------------------------\",\n \"= self.aggregate([\\\"mad\\\", \\\"approx_median\\\"]).values[self.alias] mad *= 1.4826 if mad != 0:\",\n \"---# def var(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using 'var'\",\n \"if index_stop < 0: index_stop += self.parent.shape()[0] limit = index_stop\",\n \": conditional value at risk dtype : vColumn type iqr\",\n \"or (numcol), ParameterError( \\\"The parameter 'numcol' must be a vDataFrame\",\n \"Parameters ---------- by: str, optional vColumn to use to partition\",\n \"Replaces the outliers by the NULL value. winsorize : Clips\",\n \"interval will be computed. nbins: int, optional Number of bins\",\n \"encoding of a response. \\\"\\\"\\\" check_types( [ (\\\"prefix\\\", prefix, [str]),\",\n \"query=query, title=\\\"Computing the distinct categories of {}.\\\".format(self.alias), method=\\\"fetchall\\\", ) return\",\n \"total = self.count() if method not in [\\\"mode\\\", \\\"0ifnull\\\"]: max_floor\",\n \"vColumn by the input element. Parameters ---------- x: float Input\",\n \"example to apply the function: x -> x^2 + 2\",\n \"transformation used instead of the parent vDataFrame. This parameter is\",\n \"# # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law\",\n \"following: date / int / float / text / binary\",\n \") query_result = executeSQL( query=query, title=\\\"Computing the descriptive statistics of\",\n \"mean encoding of a response. \\\"\\\"\\\" check_types( [ (\\\"prefix\\\", prefix,\",\n \"the search. Parameters ---------- val: list List of the different\",\n \"h, [int, float]), (\\\"nbins\\\", nbins, [int, float]), ] ) if\",\n \"result[i - 1], result[i], result[i - 1], result[i] ) trans\",\n \"for elem in distinct ] ), bin_spatial_to_str(self.category()), new_category.replace(\\\"'\\\", \\\"''\\\"), ),\",\n \"by, [list]), (\\\"return_trans\\\", return_trans, [bool]), ] ) method = method.lower()\",\n \"Also -------- vDataFrame.expected_store_usage : Returns the vDataFrame expected store usage.\",\n \"Vertica, taking advantage Vertica’s # speed and built-in analytics and\",\n \"self.parent._VERTICAPY_VARIABLES_[\\\"columns\\\"] += [name] self.parent.__add_to_history__( \\\"[Add Copy]: A copy of the\",\n \"{}.\\\".format(self.alias), method=\\\"fetchall\\\", ) result = [distinct_count, self.count()] + [item[1] for\",\n \"\\\"rose\\\" else False if of: self.parent.are_namecols_in(of) of = self.parent.format_colnames(of) from\",\n \"\\\"\\\", max_cardinality: Union[int, tuple] = (6, 6), h: Union[int, float,\",\n \"NameError( f\\\"A vColumn has already the alias {name}.\\\\nBy changing the\",\n \"the x limits of the current axes. ax: Matplotlib axes\",\n \"vDataFrame input aggregations. \\\"\\\"\\\" return self.aggregate(func=[\\\"prod\\\"]).values[self.alias][0] prod = product #\",\n \"self.isnum() and method == \\\"same_freq\\\": assert nbins >= 2, ParameterError(\",\n \"func not in (\\\"log\\\", \\\"mod\\\", \\\"pow\\\", \\\"round\\\"): expr = \\\"{}({})\\\".format(func.upper(),\",\n \"Returns ------- str vColumn category. See Also -------- vDataFrame[].ctype :\",\n \"available only if the parameter 'by' is empty\\\\nIf you want\",\n \"See Also -------- vDataFrame[].slice : Slices the vColumn using a\",\n \"# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express\",\n \"def sem(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using 'sem' (standard\",\n \"vColumns categories. Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].decode\",\n \"def topk(self, k: int = -1, dropna: bool = True):\",\n \"0 ELSE ZEROIFNULL(LN(pt_non_events / NULLIFZERO(pt_events))) END AS woe, CASE WHEN\",\n \"stores all user transformations. If the vDataFrame represents the entire\",\n \"changing the parameter 'name', you'll be able to solve this\",\n \"tree_id = {}, format = 'tabular'))\\\".format( tmp_model_name, i ) for\",\n \"method: str = \\\"winsorize\\\", threshold: float = 4.0, use_threshold: bool\",\n \"iv FROM ({}) x ORDER BY ord\\\".format( self.alias, query, )\",\n \"THEN argv[2 * i + 1] ... END odd :\",\n \"/\\\\ \\\"-.\\\\ \\\\ # \\\\ \\\\ \\\\'/ \\\\ \\\\ \\\\____\",\n \"{} using the following mapping:{}\\\".format( self.alias, text_info ) ) return\",\n \"\\\"Describes the statics of {} partitioned by {}.\\\".format( numcol, self.alias\",\n \"= True if len(args) > 0: column = args[0] elif\",\n \"the lower bound itself and the values higher than the\",\n \"= \\\"(CASE {}{}ELSE {} END)\\\".format(lower_when, upper_when, \\\"{}\\\") self.apply(func=func) return self.parent\",\n \"case of discretization using the method 'smart'.\\\" ) self.parent.are_namecols_in(response) response\",\n \"Regular expression. Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].str_count\",\n \"method: str = \\\"auto\\\", h: float = 0, nbins: int\",\n \"Catalog where each key corresponds to an aggregation. vColumns will\",\n \"else \\\" DESC\\\" partition_by = ( \\\"PARTITION BY {}\\\".format( \\\",\",\n \"Returns ------- ax Matplotlib axes object See Also -------- vDataFrame.boxplot\",\n \"(isinstance(index_start, int)): index_start = 0 if index_start < 0: index_start\",\n \"store_usage = executeSQL( \\\"SELECT ZEROIFNULL(SUM(LENGTH({}::varchar))) FROM {}\\\".format( bin_spatial_to_str(self.category(), self.alias), self.parent.__genSQL__(),\",\n \"x\\\".format( self.alias, query, ) query = \\\"SELECT {} AS index,\",\n \"median) / (1.4826 * mad) minmax : Normalization using the\",\n \"vColumn. Parameters ---------- limit: int, optional Number of elements to\",\n \") warnings.warn(warning_message, Warning) return self elif method == \\\"minmax\\\": if\",\n \"\\\"donut\\\" else False rose = True if pie_type == \\\"rose\\\"\",\n \"http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed\",\n \"2 in case of discretization using the method 'same_freq'\\\" )\",\n \"optional If set to True, NULL values will not be\",\n \"check_types([(\\\"new_name\\\", new_name, [str])]) old_name = quote_ident(self.alias) new_name = new_name.replace('\\\"', \\\"\\\")\",\n \"Returns ------- bool True if the vColumn category is date.\",\n \"return self.head(limit=verticapy.options[\\\"max_rows\\\"])._repr_html_() # ---# def __setattr__(self, attr, val): self.__dict__[attr] =\",\n \"- min) by: list, optional vColumns used in the partition.\",\n \"The vColumn will be transformed. Parameters ---------- pat: str regular\",\n \"to the dependent variable. Parameters ---------- y: str Response vColumn.\",\n \"data. count : Number of elements. density : Percentage of\",\n \"): \\\"\\\"\\\" --------------------------------------------------------------------------- Draws the Time Series of the vColumn.\",\n \"empty, names will be generated. include_lowest: bool, optional If set\",\n \"quote_ident(name.replace('\\\"', \\\"_\\\")) assert name.replace('\\\"', \\\"\\\"), EmptyParameter( \\\"The parameter 'name' must\",\n \"[list])]) val = {self.alias: val} return self.parent.isin(val) # ---# def\",\n \"-------- vDataFrame[].isdate : Returns True if the vColumn category is\",\n \"\\\"The parameter 'numcol' must be a vDataFrame column if the\",\n \"AS 'approx_75%', APPROXIMATE_PERCENTILE ({3}{4} USING PARAMETERS percentile = 0.9) AS\",\n \"== \\\"sturges\\\": best_h = sturges elif method.lower() in (\\\"freedman_diaconis\\\", \\\"fd\\\"):\",\n \"convert the vColumn. If this parameter is equal to 0,\",\n \"[str]), (\\\"method\\\", method, [str]), (\\\"of\\\", of, [str]), (\\\"max_cardinality\\\", max_cardinality, [list]),\",\n \"{}\\\".format( self.alias, len(all_new_features), conj, \\\", \\\".join(all_new_features) ) + \\\".\\\" )\",\n \"\\\"POWER({}, 2) + 2\\\". copy_name: str, optional If not empty,\",\n \"* FROM {} WHERE {} IS NOT NULL ORDER BY\",\n \"for processing, VerticaPy brings the logic to the data. #\",\n \"a new feature by evaluating some conditions. vDataFrame[].discretize : Discretizes\",\n \"# ---# def sum(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using\",\n \"vColumn expected store usage (unit: b). Returns ------- int vColumn\",\n \"!\\\") return self.apply(func=\\\"{} / ({})\\\".format(\\\"{}\\\", x)) # ---# def drop(self,\",\n \"= 30): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns the k most occurent elements,\",\n \": maximum mean : average median : median min :\",\n \"# ---# def clip(self, lower=None, upper=None): \\\"\\\"\\\" --------------------------------------------------------------------------- Clips the\",\n \"using an advanced analytical function on a specific vColumn. \\\"\\\"\\\"\",\n \"(only if the vColumn type is date like). The vColumn\",\n \"to be used as categorical. The less frequent elements will\",\n \"vColumn is boolean. vDataFrame[].isnum : Returns True if the vColumn\",\n \": CASE ... WHEN vColumn = argv[2 * i] THEN\",\n \"of expressions. The expression generated will look like: even: CASE\",\n \"True, ): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using 'median'. Parameters\",\n \"its affiliates. # Licensed under the Apache License, Version 2.0\",\n \"for elem in transformations], ) self.catalog = { \\\"cov\\\": {},\",\n \"max_floor = len(self.parent[elem].transformations) max_floor -= len(self.transformations) for k in range(max_floor):\",\n \"a vColumn means simply not selecting it in the final\",\n \") ) return self.parent except Exception as e: raise ConversionError(\",\n \"BY {} ASC LIMIT {}\\\".format( self.parent.__genSQL__(), self.alias, self.alias, n )\",\n \"/ 3.0), 1e-99) if method.lower() == \\\"sturges\\\": best_h = sturges\",\n \"- total) except Exception as e: self.transformations = [elem for\",\n \"---# def min(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using 'min'\",\n \"(\\\"right\\\", right, [bool]), ] ) assert self.isnum() or self.isdate(), TypeError(\",\n \"[(func, ctype, category)] self.parent[copy_name].catalog = self.catalog self.parent.__add_to_history__( \\\"[Apply]: The vColumn\",\n \"\\\"\\\\n\\\" for k in range(len(distinct_elements)): expr += [ \\\"'{}', {}\\\".format(str(distinct_elements[k]).replace(\\\"'\\\",\",\n \"the vColumn is numerical , 'categorical' otherwise. categorical : Uses\",\n \"if the absolute value of the record is greater than\",\n \"\\\"If the method is in ffill|pad|bfill|backfill then 'order_by' must be\",\n \"self.catalog[elem] self.parent.__update_catalog__(erase=True, columns=[self.alias]) total = abs(self.count() - total) except Exception\",\n \"new_column = \\\"COALESCE({}, {}({}) OVER (PARTITION BY {}))\\\".format( \\\"{}\\\", fun,\",\n \"the discretization. topk : Keeps the topk most frequent categories\",\n \"self.category())] self.transformations += [(new_column, ctype, category)] try: sauv = {}\",\n \"Returns ------- int vColumn cardinality (or approximate cardinality). See Also\",\n \"2 quantiles used to draw the Plot. start_date: str /\",\n \"the category of the vColumn. The category will be one\",\n \"== \\\"winsorize\\\": self.clip(lower=p_alpha, upper=p_1_alpha) elif method == \\\"null\\\": self.apply( func=\\\"(CASE\",\n \"rose = True if pie_type == \\\"rose\\\" else False if\",\n \"\\\"_\\\") ) n = 1 if drop_first else 0 for\",\n \"of: self.parent.are_namecols_in(of) of = self.parent.format_colnames(of) from verticapy.plot import spider as\",\n \"ORDER BY COUNT(*)\\\" \\\" DESC OFFSET {1}) VERTICAPY_SUBTABLE) ORDER BY\",\n \"self.parent[copy_name].catalog = self.catalog self.parent.__add_to_history__( \\\"[Apply]: The vColumn '{}' was transformed\",\n \"\\\"Length of parameter 'breaks' must be greater or equal to\",\n \"for elem in all_partition: if len(self.parent[elem].transformations) > max_floor: max_floor =\",\n \"[ f\\\"'{first_elem}' {op1} {column} AND {column} {op2} '{second_elem}' THEN '{label}'\\\"\",\n \"be transformed. Parameters ---------- to_replace: str Regular expression to replace.\",\n \"the vColumn using the average of the response partitioned by\",\n \"by[0], ), title=\\\"Computing the different categories {} to normalize.\\\".format( by[0]\",\n \"\\\"\\\"\\\" --------------------------------------------------------------------------- Subtracts the input element from the vColumn. Parameters\",\n \"), print_time_sql=False, ) except: cmax, cmin = ( \\\"MAX({}) OVER\",\n \"/\\\\ \\\\/\\\\ \\\\ /\\\\ \\\"-./ \\\\ /\\\\ \\\"-.\\\\ \\\\ #\",\n \"largest vColumn elements. \\\"\\\"\\\" check_types([(\\\"n\\\", n, [int, float])]) query =\",\n \"available on type numeric|date\\\" ) if self.isnum(): result = (\",\n \"len(args) > 0: column = args[0] elif \\\"column\\\" in kwargs:\",\n \"area: bool = False, step: bool = False, ax=None, **style_kwds,\",\n \"else \\\"\\\" query = \\\"SELECT {} AS {}, COUNT(*) AS\",\n \"(byte) See Also -------- vDataFrame.memory_usage : Returns the vDataFrame memory\",\n \"vColumn. Parameters ---------- ts: str TS (Time Series) vColumn to\",\n \"the vColumn. The vColumn will be transformed. Parameters ---------- start:\",\n \"/ text / binary / spatial / uuid / undefined\",\n \"tangent x: int/float, optional If the function has two arguments\",\n \"Computes the vDataFrame input aggregations. \\\"\\\"\\\" check_types([(\\\"dropna\\\", dropna, [bool]), (\\\"n\\\",\",\n \"\\\"\\\"\\\" check_types([(\\\"x\\\", x, [int, float], (\\\"approx\\\", approx, [bool]))]) prefix =\",\n \"\\\".format(\\\"{}\\\", upper, upper) if (isinstance(upper, (float, int))) else \\\"\\\" )\",\n \"Returns the vDataFrame expected store usage. \\\"\\\"\\\" pre_comp = self.parent.__get_catalog_value__(self.alias,\",\n \"of the vColumn records. The vColumn will be transformed. Parameters\",\n \"x, [int, float])]) assert x != 0, ValueError(\\\"Division by 0\",\n \"the input method. Parameters ---------- method: str, optional The describe\",\n \"/ TIMEZONE_MINUTE / WEEK / YEAR Returns ------- vDataFrame self.parent\",\n \"discretize the vColumn. auto : Uses method 'same_width' for numerical\",\n \"h: float = 0, max_cardinality: int = 8, cat_priority: list\",\n \"store=False, ) try: result = model.fit(self.parent.__genSQL__(), [self.alias]).plot( ax=ax, **style_kwds )\",\n \"if self.isnum() else \\\"topk\\\", nbins=nbins, k=nbins, new_category=\\\"Others\\\", return_enum_trans=True, )[0].replace(\\\"{}\\\", self.alias)\",\n \"------- float vColumn memory usage (byte) See Also -------- vDataFrame.memory_usage\",\n \"self.catalog[\\\"mad\\\"] = 1 / 1.4826 elif method == \\\"zscore\\\": self.catalog[\\\"mean\\\"]\",\n \"float product See Also -------- vDataFrame.aggregate : Computes the vDataFrame\",\n \"regular width bins. smart : Uses the Random Forest on\",\n \"naming.\\\\nBy changing one of \\\" \\\"the parameters ('prefix', 'prefix_sep'), you'll\",\n \"0 and 1 (1 meaning global outlier). \\\"\\\"\\\" check_types( [\",\n \"(\\\"pie_type\\\", pie_type, [\\\"auto\\\", \\\"donut\\\", \\\"rose\\\"]), ] ) donut = True\",\n \"Value (IV) / Weight Of Evidence (WOE) Table. It tells\",\n \"children vColumns whereas one vColumn can only have one parent.\",\n \"threshold ) ) else: p_alpha, p_1_alpha = ( self.parent.quantile([alpha, 1\",\n \"= \\\"\\\"): \\\"\\\"\\\" --------------------------------------------------------------------------- Replaces the regular expression matches in\",\n \"decrease. Returns ------- int vColumn cardinality (or approximate cardinality). See\",\n \"number round : rounds a value to a specified number\",\n \": Encodes the vColumn with Label Encoding. vDataFrame[].mean_encode : Encodes\",\n \"conducting # data science projects on data stored in Vertica,\",\n \"vColumn category is date. \\\"\\\"\\\" return self.category() in (\\\"float\\\", \\\"int\\\")\",\n \"n, [int, float])]) query = \\\"SELECT * FROM {} WHERE\",\n \"vColumns simplify several processes with its abstractions. Parameters ---------- alias:\",\n \"testing purpose. Returns ------- vDataFrame self.parent See Also -------- vDataFrame.outliers\",\n \"[1, 0]) or self.isbool(): all_new_features = [] prefix = (\",\n \"the following: CENTURY / DAY / DECADE / DOQ /\",\n \"/ # | \\\\/ / / / # |______ /\",\n \"'\\\"{}{}\\\"'.format( prefix, str(distinct_elements[k]).replace('\\\"', \\\"_\\\") ) ) assert not (self.parent.is_colname_in(name)), NameError(\",\n \"-------- vDataFrame.boxplot : Draws the Box Plot of the input\",\n \"\\\"NULLIFZERO\\\" if (nullifzero) else \\\"\\\", cmax, cmin, ) else: final_transformation\",\n \"maximum mean : average median : median min : minimum\",\n \"vColumn. auto : Uses method 'same_width' for numerical vColumns, cast\",\n \"Aggregates the vColumn using 'max' (Maximum). Returns ------- float/str maximum\",\n \"mul(self, x: float): \\\"\\\"\\\" --------------------------------------------------------------------------- Multiplies the vColumn by the\",\n \"an \\\"AS IS\\\" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF\",\n \"< int(float(count / int(nbins))) * int(nbins): nth_elems += [str(total)] total\",\n \"self, by: str = \\\"\\\", bandwidth: float = 1.0, kernel:\",\n \"Evaluates a customized expression. \\\"\\\"\\\" check_types([(\\\"name\\\", name, [str])]) name =\",\n \"Drops outliers in the vColumn. Parameters ---------- threshold: float, optional\",\n \"y) result = to_tablesample(query, title=title) result.values[\\\"index\\\"] += [\\\"total\\\"] result.values[\\\"non_events\\\"] +=\",\n \"cmin = \\\"DECODE({}, {}, NULL)\\\".format( by[0], \\\", \\\".join( [ \\\"{},\",\n \"will be computed if the parameter is empty or invalid.\",\n \"the vColumn using as lower bound quantile(alpha) and as upper\",\n \"trigonometric tangent tanh : hyperbolic tangent x: int/float, optional If\",\n \"the n largest vColumn elements. Parameters ---------- n: int, optional\",\n \"{}) / {}({})\\\".format( \\\"{}\\\", avg, \\\"NULLIFZERO\\\" if (nullifzero) else \\\"\\\",\",\n \"result = executeSQL( query=query, title=\\\"Computing the optimized histogram nbins using\",\n \"\\\"regr_count\\\": {}, \\\"regr_intercept\\\": {}, \\\"regr_r2\\\": {}, \\\"regr_slope\\\": {}, \\\"regr_sxx\\\": {},\",\n \"|| ''\\\", \\\"varchar\\\", \\\"text\\\") else: trans = (\\\"{} || ''\\\",\",\n \"the Type casting.\\\") self.transformations += [ ( \\\"{}::{}\\\".format(\\\"{}\\\", dtype), dtype,\",\n \"[(new_column, ctype, category)] try: sauv = {} for elem in\",\n \"vdf_table AS (SELECT * FROM {}) {}\\\".format( self.parent.__genSQL__(), query )\",\n \"len(self.transformations) for k in range(max_floor): self.transformations += [(\\\"{}\\\", self.ctype(), self.category())]\",\n \"= \\\"SELECT split_value FROM (SELECT split_value, MAX(weighted_information_gain) FROM ({}) VERTICAPY_SUBTABLE\",\n \"\\\"\\\"\\\" if isinstance(func, str_sql): func = str(func) check_types([(\\\"func\\\", func, [str]),\",\n \"vColumn with user defined Encoding. vDataFrame[].get_dummies : Encodes the vColumn\",\n \"[self.alias], response) query = [ \\\"(SELECT READ_TREE(USING PARAMETERS model_name =\",\n \"add_history: bool, optional If set to True, the information will\",\n \"(\\\"ts\\\", ts, [str]), (\\\"q\\\", q, [tuple]), ( \\\"start_date\\\", start_date, [str,\",\n \"The catalog will be updated when the parent vDataFrame is\",\n \"return self.aggregate([\\\"avg\\\"]).values[self.alias][0] mean = avg # ---# def bar( self,\",\n \"the new categories. If empty, names will be generated. include_lowest:\",\n \"list List of values used to cut the vColumn. labels:\",\n \"max_cardinality: int, optional Maximum number of the vColumn distinct elements\",\n \"= self.discretize( method=\\\"same_width\\\" if self.isnum() else \\\"topk\\\", nbins=nbins, k=nbins, new_category=\\\"Others\\\",\",\n \"method, of, max_cardinality, nbins, h, ax=ax, **style_kwds) # ---# def\",\n \"a response. \\\"\\\"\\\" check_types( [ (\\\"RFmodel_params\\\", RFmodel_params, [dict]), (\\\"return_enum_trans\\\", return_enum_trans,\",\n \"by, h, max_cardinality, cat_priority, ax=ax, **style_kwds) # ---# def category(self):\",\n \"colors[idx % len(colors)]} ax = self.parent.search( \\\"{} = '{}'\\\".format(self.parent[by].alias, column)\",\n \"drop(tmp_model_name, method=\\\"model\\\") raise drop(tmp_view_name, method=\\\"view\\\") drop(tmp_model_name, method=\\\"model\\\") result = [self.min()]\",\n \"Frequency discretization\\\" ) total, query, nth_elems = nb, [], []\",\n \"verticapy.options[\\\"temp_schema\\\"] if not (schema): schema = \\\"public\\\" name = gen_tmp_name(schema=schema,\",\n \"pt_non_events, pt_events, CASE WHEN non_events = 0 OR events =\",\n \"cat_priority: list, optional List of the different categories to consider\",\n \"return self.parent # ---# def median( self, approx: bool =\",\n \"= [ ( \\\"({} - {}) / {}({} - {})\\\".format(\",\n \"mode : mode (most occurent element). 0ifnull : 0 when\",\n \"the data. # # # Modules # # Standard Python\",\n \"type is date like (date, datetime ...), the parameter 'x'\",\n \"of digits after the comma. Parameters ---------- n: int Number\",\n \"nbins: int = 200, xlim: tuple = None, ax=None, **style_kwds,\",\n \"Parameters ---------- limit: int, optional Number of elements to display.\",\n \"the vColumn category is date, False otherwise. Returns ------- bool\",\n \"Plot. ax: Matplotlib axes object, optional The axes to plot\",\n \"methods. Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].dropna :\",\n \"self.catalog[elem] self.parent.__update_catalog__(erase=True, columns=[self.alias]) try: if \\\"count\\\" in sauv: self.catalog[\\\"count\\\"] =\",\n \"| \\\\/ / / / # |______ / / /\",\n \"\\\"minmax\\\": self.catalog[elem] = (sauv[elem] - sauv[\\\"min\\\"]) / ( sauv[\\\"max\\\"] -\",\n \"the lower bound to the lower bound itself and the\",\n \"h will be picked or computed) h: float, optional Interval\",\n \"<= 0: h = self.numh() else: h = (self.max() -\",\n \"power of an independent variable in relation to the dependent\",\n \"the Bar Chart of vColumn based on an aggregation. \\\"\\\"\\\"\",\n \"mean, STDDEV({3}{4}) AS std, MIN({3}{4}) AS min, APPROXIMATE_PERCENTILE ({3}{4} USING\",\n \"list = [], ): \\\"\\\"\\\" --------------------------------------------------------------------------- Fills missing elements in\",\n \"[int, float]), (\\\"offset\\\", offset, [int, float])]) if offset < 0:\",\n \"silverman : Silverman kernel. nbins: int, optional Maximum number of\",\n \"True, the approximate median is returned. By setting this parameter\",\n \"For more information, see: https://geopandas.readthedocs.io/en/latest/docs/reference/api/ geopandas.GeoDataFrame.plot.html Returns ------- ax Matplotlib\",\n \"+= [sum(result[\\\"iv\\\"])] return result # ---# def kurtosis(self): \\\"\\\"\\\" ---------------------------------------------------------------------------\",\n \"{} IN ({}) THEN {} || '' ELSE '{}' END)\\\".format(\",\n \"Returns the n smallest elements in the vColumn. \\\"\\\"\\\" check_types([(\\\"n\\\",\",\n \"function's performance can drastically decrease. Returns ------- float quantile (or\",\n \"and two input quantiles. Parameters ---------- ts: str TS (Time\",\n \"FROM (SELECT COUNT(*) AS count\\\" \\\" FROM vdf_table WHERE {0}\",\n \"copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # #\",\n \": standard deviation topk : kth most occurent element (ex:\",\n \"If set to True, draw a Step Plot. ax: Matplotlib\",\n \"---# def date_part(self, field: str): \\\"\\\"\\\" --------------------------------------------------------------------------- Extracts a specific\",\n \"vColumn. \\\"\\\"\\\" check_types([(\\\"new_name\\\", new_name, [str])]) old_name = quote_ident(self.alias) new_name =\",\n \"pat.replace(\\\"'\\\", \\\"''\\\")) ) # ---# def str_count(self, pat: str): \\\"\\\"\\\"\",\n \"TypeError( \\\"cut only works on numerical / date-like vColumns.\\\" )\",\n \"{} AS {}, COUNT(*) AS _verticapy_cnt_, 100 * COUNT(*) /\",\n \"Encoding algorithm. Parameters ---------- prefix: str, optional Prefix of the\",\n \"time series rule. Parameters ---------- length: int Slice size. unit:\",\n \"assert self.isnum() or self.isdate(), ParameterError( \\\"numh is only available on\",\n \"or (self.category() == \\\"float\\\"): trans = ( \\\"'[' || FLOOR({}\",\n \"Returns ------- vDataFrame self.parent See Also -------- vDataFrame.apply : Applies\",\n \"/ MINUTE / MONTH / QUARTER / SECOND / TIME\",\n \"ORDER BY _verticapy_cnt_ DESC LIMIT {}) VERTICAPY_SUBTABLE ORDER BY _verticapy_cnt_\",\n \"] ) donut = True if pie_type == \\\"donut\\\" else\",\n \"+ result[\\\"avg\\\"][0], threshold * result[\\\"std\\\"][0] + result[\\\"avg\\\"][0], ) else: query\",\n \"self.alias ) warnings.warn(warning_message, Warning) return self elif method == \\\"minmax\\\":\",\n \") query = \\\"SELECT COUNT({}) AS NAs, MIN({}) AS min,\",\n \"aggregations. \\\"\\\"\\\" check_types( [ (\\\"method\\\", method, [\\\"auto\\\", \\\"numerical\\\", \\\"categorical\\\", \\\"cat_stats\\\"]),\",\n \"method=\\\"model\\\") if self.parent[response].category() == \\\"float\\\": model = RandomForestRegressor(tmp_model_name) else: model\",\n \"\\\"sigmoid\\\", \\\"silverman\\\"]), (\\\"bandwidth\\\", bandwidth, [int, float]), (\\\"nbins\\\", nbins, [float, int]),\",\n \"\\\"smart\\\" ): n = len(result) trans = \\\"(CASE \\\" for\",\n \"a default function to the vColumn. Parameters ---------- func: str\",\n \"method=\\\"fetchall\\\", ) for i in range(len(result)): if result[i][2] == None:\",\n \"optional Slice size unit. For example, it can be 'minute'\",\n \"limit = index_stop - index_start if limit <= 0: limit\",\n \"0.05 ): \\\"\\\"\\\" --------------------------------------------------------------------------- Drops outliers in the vColumn. Parameters\",\n \"float, optional Upper bound. Returns ------- vDataFrame self.parent See Also\",\n \"axes object See Also -------- vDataFrame[].bar : Draws the Bar\",\n \"\\\" self.parent.__add_to_history__( \\\"[Get Dummies]: One hot encoder was applied to\",\n \"self.catalog[\\\"percent\\\"] = ( 100 * sauv[\\\"count\\\"] / self.parent.shape()[0] ) for\",\n \"None avg = \\\"DECODE({}, {}, NULL)\\\".format( by[0], \\\", \\\".join( [\",\n \"int = 10): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns the n smallest elements\",\n \"method. \\\"\\\"\\\" check_types([(\\\"lower\\\", lower, [float, int]), (\\\"upper\\\", upper, [float, int])])\",\n \"self.parent.shape()[0], \\\"percent\\\": 100.0, \\\"unique\\\": 2, \\\"approx_unique\\\": 2, \\\"prod\\\": 0, },\",\n \"= self.parent.format_colnames(by) from verticapy.plot import gen_colors from matplotlib.lines import Line2D\",\n \"If set to True, draw an Area Plot. step: bool,\",\n \"ax=ax, **style_kwds) # ---# def boxplot( self, by: str =\",\n \"when 'method' is set to 'smart'. A RF Regressor will\",\n \"\\\"regr_syy\\\": {}, } for elem in catalog: self.catalog[elem] = catalog[elem]\",\n \"means simply not selecting it in the final generated SQL\",\n \"(\\\"nbins\\\", nbins, [int, float]), (\\\"h\\\", h, [int, float]), ] )\",\n \"(self.parent[by[0]].nunique() < 50): try: result = executeSQL( \\\"SELECT {}, AVG({}),\",\n \"can drastically decrease. Returns ------- int vColumn cardinality (or approximate\",\n \"(None, None), ax=None, **style_kwds, ): \\\"\\\"\\\" --------------------------------------------------------------------------- Draws the spider\",\n \"\\\"\\\"\\\" if isinstance(val, str) or not (isinstance(val, Iterable)): val =\",\n \"\\\\_____\\\\ \\\\ \\\\_____\\\\ \\\\ \\\\_\\\\ \\\\ \\\\_\\\\ \\\\ \\\\_\\\\\\\\\\\"\\\\_\\\\ #\",\n \"get the median). It can also be a cutomized aggregation\",\n \"---------- by: str, optional vColumn to use to partition the\",\n \"self.parent.__get_last_order_by__(), index_start, limit, ) return vDataFrameSQL(query) elif isinstance(index, int): cast\",\n \"func: str Function to use to transform the vColumn. abs\",\n \"|| ';' || (FLOOR({} / {}) * {} + {}{})\",\n \": value down to the next whole number ln :\",\n \"return self.apply( func=\\\"REGEXP_COUNT({}, '{}')\\\".format(\\\"{}\\\", pat.replace(\\\"'\\\", \\\"''\\\")) ) # ---# def\",\n \"OFFSET {}{}) VERTICAPY_SUBTABLE\\\".format( self.alias, self.parent.__genSQL__(), self.parent.__get_last_order_by__(), index_start, limit, ) return\",\n \"vColumns to the input type. \\\"\\\"\\\" check_types([(\\\"dtype\\\", dtype, [str])]) try:\",\n \"other into one unique category. h: float, optional The interval\",\n \"range(len(breaks) - 1): first_elem, second_elem = breaks[idx], breaks[idx + 1]\",\n \"\\\"COALESCE({}, '{}')\\\".format(\\\"{}\\\", val) elif expr: new_column = \\\"COALESCE({}, {})\\\".format(\\\"{}\\\", expr)\",\n \"[int, float])]) return self.apply(func=\\\"{} * ({})\\\".format(\\\"{}\\\", x)) # ---# def\",\n \"of the kernel. kernel: str, optional The method used for\",\n \"|| '' ELSE '{}' END)\\\".format( bin_spatial_to_str(self.category()), \\\", \\\".join( [ \\\"'{}'\\\".format(str(elem).replace(\\\"'\\\",\",\n \"if not (\\\"legend\\\" in kwargs): kwargs[\\\"legend\\\"] = True if not\",\n \"/ MILLISECONDS / MINUTE / MONTH / QUARTER / SECOND\",\n \"bins. If empty, an optimized number of bins will be\",\n \"\\\"\\\" query, cat = [], self.distinct() if len(cat) == 1:\",\n \"quantile is returned. By setting this parameter to False, the\",\n \"== 2, TypeError( \\\"vColumn {} must be binary to use\",\n \"(6, 6), h: Union[int, float, tuple] = (None, None), ax=None,\",\n \"e: raise QueryError( \\\"{}\\\\nError when applying the func 'x ->\",\n \"if the vColumn is boolean. vDataFrame[].isnum : Returns True if\",\n \"not in [\\\"mode\\\", \\\"0ifnull\\\"]: max_floor = 0 all_partition = by\",\n \"vDataFrame.aggregate : Computes the vDataFrame input aggregations. \\\"\\\"\\\" return self.quantile(0.5,\",\n \"sauv[\\\"count\\\"] / self.parent.shape()[0] ) except: pass self.parent.__add_to_history__( \\\"[Discretize]: The vColumn\",\n \"will filter the data when 'ts' is greater than November\",\n \"/ # \\\\ / / / # \\\\ / /\",\n \"mean_1_alpha == None: mean_alpha = \\\"NULL\\\" self.apply( func=\\\"(CASE WHEN {}\",\n \"[bool]), ] ) assert self.isnum() or self.isdate(), TypeError( \\\"cut only\",\n \"result[\\\"avg\\\"][0], threshold * result[\\\"std\\\"][0] + result[\\\"avg\\\"][0], ) else: query =\",\n \": average absolute deviation approx_unique : approximative cardinality count :\",\n \"the different categories to consider when drawing the box plot.\",\n \"------- str/float/int vColumn nth most occurent element. See Also --------\",\n \"optional New value. Returns ------- vDataFrame self.parent See Also --------\",\n \"nbins=nbins, xlim=(xmin, xmax), ax=ax, **updated_dict(param, style_kwds, idx), ) custom_lines +=\",\n \"Also -------- vDataFrame[].apply : Applies a function to the input\",\n \"distinct(self, **kwargs): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns the distinct categories of the\",\n \"the mean skewness : skewness sum : sum std :\",\n \"= \\\"MEDIAN\\\" if (method == \\\"median\\\") else \\\"AVG\\\" if by\",\n \"to True, the method will return the transformation used instead\",\n \"numerical vColumns, cast the other types to varchar. same_freq :\",\n \"(FLOOR({} / {}) * {} + {}{}) || ']'\\\".format( \\\"{}\\\",\",\n \"y, [str]), (\\\"nbins\\\", nbins, [int])]) self.parent.are_namecols_in(y) y = self.parent.format_colnames(y) assert\",\n \"def rename(self, new_name: str): \\\"\\\"\\\" --------------------------------------------------------------------------- Renames the vColumn by\",\n \"the func 'x -> {}'.\\\".format( copy_name.replace('\\\"', \\\"\\\"), func.replace(\\\"{}\\\", \\\"x\\\"), )\",\n \"parameter 'by' is empty\\\\nIf you want to normalize by grouping\",\n \"index mad : median absolute deviation max : maximum mean\",\n \"used to name the new categories. If empty, names will\",\n \"1 and 2 to be used as categorical (No h\",\n \"(float, int))) else \\\"\\\" ) upper_when = ( \\\"WHEN {}\",\n \"\\\\/_____/ \\\\/_____/ \\\\/_/ \\\\/_/ \\\\/_/ \\\\/_/ # # # ---#\",\n \"self.transformations += [(\\\"{}\\\", self.ctype(), self.category())] self.transformations += final_transformation sauv =\",\n \": rounds a value to a specified number of decimal\",\n \"(\\\"method\\\", method, [str]), (\\\"of\\\", of, [str]), (\\\"max_cardinality\\\", max_cardinality, [list]), (\\\"h\\\",\",\n \"= self.ctype() tail.name = self.alias return tail # ---# def\",\n \"= \\\"Describes the statics of {} partitioned by {}.\\\".format( numcol,\",\n \"than the threshold, it will be considered as an outlier.\",\n \"FROM (SELECT {}, ROW_NUMBER() OVER (ORDER BY {}) AS _verticapy_row_nb_\",\n \"= index.start if not (isinstance(index_start, int)): index_start = 0 if\",\n \"the parent vDataFrame is modified. Attributes ---------- alias, str :\",\n \"or computed) nbins: int, optional Number of bins. If empty,\",\n \"--------------------------------------------------------------------------- Aggregates the vColumn using an input 'quantile'. Parameters ----------\",\n \"mod : remainder of a division operation pow : number\",\n \"approximate cardinality is returned. By setting this parameter to False,\",\n \"\\\"\\\"\\\" --------------------------------------------------------------------------- Python object which that stores all user transformations.\",\n \"where, ) result = executeSQL( query=query, title=\\\"Computing the equal frequency\",\n \"x^2 + 2 use \\\"POWER({}, 2) + 2\\\". copy_name: str,\",\n \"\\\\'/ \\\\ \\\\ \\\\____ \\\\ \\\\ \\\\/\\\\ \\\\ \\\\ \\\\\",\n \"of the list will be included. right: bool, optional How\",\n \"--------------------------------------------------------------------------- Extracts a specific TS field from the vColumn (only\",\n \"vColumn means simply not selecting it in the final generated\",\n \"new_category=\\\"Others\\\", return_enum_trans=True, )[0].replace(\\\"{}\\\", self.alias) query = \\\"SELECT {} AS {},\",\n \"using 'skewness'. Returns ------- float skewness See Also -------- vDataFrame.aggregate\",\n \"str, value: str = \\\"\\\"): \\\"\\\"\\\" --------------------------------------------------------------------------- Replaces the regular\",\n \"(SELECT {}, COUNT(*) AS _verticapy_cnt_ FROM {}{}GROUP BY {} ORDER\",\n \"Sturges [CEIL(log2(n)) + 1] Returns ------- float optimal bar width.\",\n \"Values lesser than quantile(alpha) or greater than quantile(1-alpha) will be\",\n \"self.alias, self.alias, self.parent.__genSQL__(), by[0], ), title=\\\"Computing the different categories {}\",\n \"---# def str_replace(self, to_replace: str, value: str = \\\"\\\"): \\\"\\\"\\\"\",\n \"the vColumn. \\\"\\\"\\\" check_types([(\\\"new_name\\\", new_name, [str])]) old_name = quote_ident(self.alias) new_name\",\n \"utilities.tablesample. See Also -------- vDataFrame[].nsmallest : Returns the n smallest\",\n \"geo_plot(self, *args, **kwargs): \\\"\\\"\\\" --------------------------------------------------------------------------- Draws the Geospatial object. Parameters\",\n \"are the median and two input quantiles. Parameters ---------- ts:\",\n \"when the parameter method is set to 'cat_stats'. Returns -------\",\n \"executeSQL( query=query, title=\\\"Getting the vColumn element.\\\", method=\\\"fetchfirstelem\\\", ) else: return\",\n \"max_floor = max( len(self.parent[column].transformations), max_floor ) except: pass max_floor -=\",\n \"return self.aggregate([\\\"aad\\\"]).values[self.alias][0] # ---# def abs(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Applies the\",\n \"'name', you'll be able to solve this issue.\\\" ) new_vColumn\",\n \"parameter. alpha: float, optional Number representing the outliers threshold. Values\",\n \"(x - min) / (max - min) by: list, optional\",\n \"optimal h.\\\", method=\\\"fetchrow\\\", ) count, vColumn_min, vColumn_025, vColumn_075, vColumn_max =\",\n \"re.compile(\\\"\\\\\\\\b{}\\\\\\\\b\\\".format(column.replace('\\\"', \\\"\\\"))), func ) ): max_floor = max( len(self.parent[column].transformations), max_floor\",\n \"elif math.isnan(result[i][2]): result[i][2] = None avg = \\\"DECODE({}, {}, NULL)\\\".format(\",\n \"Also -------- vDataFrame[].head : Returns the head of the vColumn.\",\n \"{}({})\\\".format( \\\"{}\\\", avg, \\\"NULLIFZERO\\\" if (nullifzero) else \\\"\\\", stddev ),\",\n \"transformed. Parameters ---------- start: int Start of the slicing. step:\",\n \": Draws the donut chart of the vColumn based on\",\n \"vDataFrame self.parent See Also -------- vDataFrame.add_copy : Creates a copy\",\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 \"cutomized aggregation (ex: AVG(column1) + 5). of: str, optional The\",\n \"by = self.parent.format_colnames(by) nullifzero, n = 1, len(by) if self.isbool():\",\n \"= \\\"auto\\\", h: float = 0, nbins: int = -1,\",\n \"\\\"Reads {} {} smallest elements.\\\".format(n, self.alias) return to_tablesample(query, title=title) #\",\n \"---------- to_replace: str Regular expression to replace. value: str, optional\",\n \"\\\"-./ \\\\ /\\\\ \\\"-.\\\\ \\\\ # \\\\ \\\\ \\\\'/ \\\\\",\n \"def kurtosis(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using 'kurtosis'. Returns\",\n \"vDataFrame[].describe : Computes the vColumn descriptive statistics. \\\"\\\"\\\" check_types([(\\\"k\\\", k,\",\n \"return self.ctype().lower() in (\\\"bool\\\", \\\"boolean\\\") # ---# def isdate(self): \\\"\\\"\\\"\",\n \"Response vColumn. nbins: int, optional Maximum number of nbins used\",\n \"# ---# class vColumn(str_sql): \\\"\\\"\\\" --------------------------------------------------------------------------- Python object which that\",\n \"when using the 'topk' method. RFmodel_params: dict, optional Dictionary of\",\n \"= \\\"mean\\\" if (self.isnum() and self.nunique(True) > 6) else \\\"mode\\\"\",\n \"\\\"{}\\\", by[0], \\\", \\\".join( [\\\"{}, {}\\\".format(elem[0], elem[1]) for elem in\",\n \"med, mad) else: final_transformation = [ ( \\\"({} - {})\",\n \"self.isnum(): result = ( self.parent.describe( method=\\\"numerical\\\", columns=[self.alias], unique=False ) .transpose()\",\n \"each record of the vColumn. vDataFrame[].str_slice : Slices the vColumn.\",\n \"parameter 'name' must not be empty\\\" ) assert not (self.parent.is_colname_in(name)),\",\n \"[int, float], (\\\"approx\\\", approx, [bool]))]) prefix = \\\"approx_\\\" if approx\",\n \"to True, the approximate median is returned. By setting this\",\n \": Returns True if the vColumn is numerical. \\\"\\\"\\\" return\",\n \"The vColumn {} was converted to {}.\\\".format( self.alias, dtype )\",\n \"want to normalize by grouping by elements, please use a\",\n \"\\\\_____\\\\ \\\\ \\\\_\\\\ \\\\ \\\\_\\\\ \\\\ \\\\_\\\\\\\\\\\"\\\\_\\\\ # \\\\/_/ \\\\/_____/\",\n \"of a response. \\\"\\\"\\\" check_types( [ (\\\"prefix\\\", prefix, [str]), (\\\"prefix_sep\\\",\",\n \"return self.parent # ---# def mad(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the\",\n \"in each record of the vColumn. vDataFrame[].str_replace : Replaces the\",\n \"projects on data stored in Vertica, taking advantage Vertica’s #\",\n \"item in query_result] else: result = ( self.parent.describe( method=\\\"numerical\\\", columns=[self.alias],\",\n \"return tablesample(values) # ---# def value_counts(self, k: int = 30):\",\n \"upper bound to the upper bound itself. Parameters ---------- lower:\",\n \"parameter method is set to 'cat_stats'. Returns ------- tablesample An\",\n \"use_threshold: bool, optional Uses the threshold instead of the 'alpha'\",\n \"\\\", \\\".join( [\\\"{}, {}\\\".format(elem[0], elem[1]) for elem in result] ),\",\n \"{}\\\".format(str(distinct_elements[k]).replace(\\\"'\\\", \\\"''\\\"), k) ] text_info += \\\"\\\\t{} => {}\\\".format(distinct_elements[k], k)\",\n \"\\\"'[' || FLOOR({} / {}) * {} || ';' ||\",\n \"# ---# def aggregate(self, func: list): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the\",\n \"will be computed. h: float, optional Interval width of the\",\n \"input element from the vColumn. Parameters ---------- x: float If\",\n \"the computation. max_cardinality: int, optional Cardinality threshold to use to\",\n \"using 'std' (Standard Deviation). Returns ------- float std See Also\",\n \"the median and two input quantiles. Parameters ---------- ts: str\",\n \"\\\"\\\", self.alias ), method=\\\"fetchall\\\", ) values = { \\\"index\\\": [item[0]\",\n \"For more information, see utilities.tablesample. See Also -------- vDataFrame[].tail :\",\n \"self.transformations += [ (\\\"AVG({}) OVER (PARTITION BY {})\\\".format(response, \\\"{}\\\"), \\\"int\\\",\",\n \"0 OR events = 0 THEN 0 ELSE ZEROIFNULL(LN(pt_non_events /\",\n \"int = 5): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns the head of the\",\n \"\\\"''\\\")) ) result[idx][1] = \\\"NULL\\\" if (elem[1] == None) else\",\n \"n = 1 then this method will return the mode\",\n \"{} THEN {} WHEN {} > {} THEN {} ELSE\",\n \"[str])]) self.parent.are_namecols_in(response) response = self.parent.format_colnames(response) assert self.parent[response].isnum(), TypeError( \\\"The response\",\n \"in compliance with the License. # You may obtain a\",\n \"= ( -threshold * result[\\\"std\\\"][0] + result[\\\"avg\\\"][0], threshold * result[\\\"std\\\"][0]\",\n \"copy_name, [str])]) try: try: ctype = get_data_types( \\\"SELECT {} AS\",\n \"category is date. \\\"\\\"\\\" return self.category() in (\\\"float\\\", \\\"int\\\") #\",\n \"--------------------------------------------------------------------------- Aggregates the vColumn using 'kurtosis'. Returns ------- float kurtosis\",\n \"table ) result = executeSQL( query, title=\\\"Different aggregations to compute\",\n \"vDataFrame[].mean_encode : Encodes the vColumn using the mean encoding of\",\n \"= model.get_params() try: model.fit(tmp_view_name, [self.alias], response) query = [ \\\"(SELECT\",\n \"--------------------------------------------------------------------------- Returns a part of the vColumn (delimited by an\",\n \"{} FROM {}{} LIMIT {} OFFSET {}\\\".format( bin_spatial_to_str(self.category(), self.alias), self.alias,\",\n \"if use_threshold: result = self.aggregate(func=[\\\"std\\\", \\\"avg\\\"]).transpose().values p_alpha, p_1_alpha = (\",\n \"alias {new_name}.\\\\nBy changing the parameter 'new_name', you'll be able to\",\n \"None), ax=None, **style_kwds, ): \\\"\\\"\\\" --------------------------------------------------------------------------- Draws the spider plot\",\n \"to 'cat_stats'. Returns ------- tablesample An object containing the result.\",\n \"the vDataFrame \\\"heavier\\\" if it is used to compute other\",\n \"chart. donut : Donut chart. rose : Rose chart. It\",\n \"Returns ------- bool True if the vColumn is boolean. See\",\n \"floor : value down to the next whole number ln\",\n \"affiliates. # Licensed under the Apache License, Version 2.0 (the\",\n \"= '03-11-1993' will filter the data when 'ts' is lesser\",\n \"transformation operations, and offers beautiful graphical options. # # VerticaPy\",\n \"else: check = False if check: self.parent.are_namecols_in(column) column = self.parent.format_colnames(column)\",\n \"---# def max(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using 'max'\",\n \"------- float product See Also -------- vDataFrame.aggregate : Computes the\",\n \"with user defined Encoding. vDataFrame[].discretize : Discretizes the vColumn. vDataFrame[].label_encode\",\n \"slicing instead of the ceiling. Returns ------- vDataFrame self.parent See\",\n \"prefix_sep.replace('\\\"', \\\"_\\\") if not (prefix) else prefix.replace('\\\"', \\\"_\\\") + prefix_sep.replace('\\\"',\",\n \"practice to use this method when first preparing your data.\",\n \"\\\"auto\\\", expr: str = \\\"\\\", by: list = [], order_by:\",\n \"the vDataFrame input aggregations. \\\"\\\"\\\" return self.aggregate([\\\"avg\\\"]).values[self.alias][0] mean = avg\",\n \"See Also -------- vDataFrame[].drop_outliers : Drops outliers in the vColumn.\",\n \"self.category() in (\\\"float\\\", \\\"int\\\") # ---# def iv_woe(self, y: str,\",\n \"self.parent._VERTICAPY_VARIABLES_[\\\"columns\\\"] += [name] all_new_features += [name] conj = \\\"s were\",\n \"), method=\\\"fetchall\\\", ) values = { \\\"index\\\": [item[0] for item\",\n \"regular expression in each record of the vColumn. vDataFrame[].extract :\",\n \"SUM(1 - {}) AS non_events, SUM({}) AS events FROM ({})\",\n \"object See Also -------- vDataFrame.boxplot : Draws the Box Plot\",\n \"\\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using 'skewness'. Returns ------- float\",\n \"100}) model.set_params(RFmodel_params) parameters = model.get_params() try: model.fit(tmp_view_name, [self.alias], response) query\",\n \"please use a method in zscore|minmax\\\" warnings.warn(warning_message, Warning) return self\",\n \": Applies a function to the input vColumn. \\\"\\\"\\\" check_types(\",\n \"{})\\\".format( self.alias, \\\", \\\".join(by) ), ) if return_trans: return \\\"({}\",\n \"str vColumn alias. transformations: list, optional List of the different\",\n \"date. vDataFrame[].isnum : Returns True if the vColumn is numerical.\",\n \"but will also increase the time of the learning and\",\n \"{}) AS non_events, SUM({}) AS events FROM ({}) x GROUP\",\n \"{}) VERTICAPY_SUBTABLE ORDER BY _verticapy_cnt_ ASC LIMIT 1\\\".format( self.alias, self.alias,\",\n \"/ {}({} - {})\\\".format( self.alias, cmin, \\\"NULLIFZERO\\\" if (nullifzero) else\",\n \"dtype: str New type. Returns ------- vDataFrame self.parent See Also\",\n \"method, [\\\"auto\\\", \\\"numerical\\\", \\\"categorical\\\", \\\"cat_stats\\\"]), (\\\"max_cardinality\\\", max_cardinality, [int, float]), (\\\"numcol\\\",\",\n \"threshold it will be considered as an outlier. use_threshold: bool,\",\n \"(is_numeric) or (method == \\\"categorical\\\") ): query = \\\"\\\"\\\"(SELECT {0}\",\n \"({})\\\".format(\\\"{}\\\", x)) # ---# def add_copy(self, name: str): \\\"\\\"\\\" ---------------------------------------------------------------------------\",\n \"most occurent elements and their distributions as percents. Parameters ----------\",\n \"< 0: index += self.parent.shape()[0] query = \\\"SELECT {}{} FROM\",\n \"datetime from collections.abc import Iterable from typing import Union #\",\n \"category is date, False otherwise. Returns ------- bool True if\",\n \"be picked or computed) nbins: int, optional Number of nbins.\",\n \"\\\"abs\\\", \\\"acos\\\", \\\"asin\\\", \\\"atan\\\", \\\"cbrt\\\", \\\"ceil\\\", \\\"cos\\\", \\\"cosh\\\", \\\"cot\\\", \\\"exp\\\",\",\n \"[self.min()] + result + [self.max()] elif method == \\\"topk\\\": assert\",\n \"[best_h]}) if self.category() == \\\"int\\\": best_h = max(math.floor(best_h), 1) return\",\n \"the vColumn using 'unique' (cardinality). Parameters ---------- approx: bool, optional\",\n \"# data science projects on data stored in Vertica, taking\",\n \"as one column of that relation. vColumns simplify several processes\",\n \"= 0 OR events = 0 THEN 0 ELSE (pt_non_events\",\n \"record of the vColumn. vDataFrame[].extract : Extracts the regular expression\",\n \"if by: self.parent.are_namecols_in(by) by = self.parent.format_colnames(by) from verticapy.plot import boxplot\",\n \"input vColumn. Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].apply\",\n \"breaks: list List of values used to cut the vColumn.\",\n \"cast the other types to varchar. same_freq : Computes bins\",\n \"title=\\\"Computing the quantiles of {}.\\\".format(self.alias), method=\\\"fetchrow\\\", ) if method ==\",\n \"with the License. # You may obtain a copy of\",\n \"close_r = \\\"<=\\\", \\\"<\\\", \\\"[\\\", \\\"[\\\" if idx == 0\",\n \"[] columns = self.parent[by].distinct() for idx, column in enumerate(columns): param\",\n \"= get_dummies # ---# def head(self, limit: int = 5):\",\n \"data when 'ts' is greater than November 1993 the 3rd.\",\n \"self.ctype(), self.category()) ] self.parent[copy_name].transformations += [(func, ctype, category)] self.parent[copy_name].catalog =\",\n \"\\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using 'sem' (standard error of\",\n \"in pure SQL used to transform the vColumn. The function\",\n \"expr = \\\"DECODE({}, '{}', 1, 0)\\\".format( \\\"{}\\\", str(distinct_elements[k]).replace(\\\"'\\\", \\\"''\\\") )\",\n \"\\\"[Discretize]: The vColumn {} was discretized.\\\".format(self.alias) ) return self.parent #\",\n \"if the vColumn category is date. See Also -------- vDataFrame[].isbool\",\n \"= \\\"gaussian\\\", nbins: int = 200, xlim: tuple = None,\",\n \"the vDataFrame input aggregations. \\\"\\\"\\\" return self.aggregate([\\\"max\\\"]).values[self.alias][0] # ---# def\",\n \"= self.parent.__get_catalog_value__(self.alias, \\\"top\\\") if pre_comp != \\\"VERTICAPY_NOT_PRECOMPUTED\\\": if not (dropna)\",\n \"columns = [self.alias] check = True if len(args) > 0:\",\n \"return_enum_trans: bool = False, ): \\\"\\\"\\\" --------------------------------------------------------------------------- Discretizes the vColumn\",\n \"the input vColumns based on an aggregation. \\\"\\\"\\\" check_types( [\",\n \"field to extract. It must be one of the following:\",\n \"operations, and offers beautiful graphical options. # # VerticaPy aims\",\n \"input aggregations. \\\"\\\"\\\" return self.aggregate(func=[\\\"prod\\\"]).values[self.alias][0] prod = product # ---#\",\n \"pie chart. donut : Donut chart. rose : Rose chart.\",\n \"\\\"\\\"\\\" --------------------------------------------------------------------------- Clips the vColumn by transforming the values lesser\",\n \"{}, format = 'tabular'))\\\".format( tmp_model_name, i ) for i in\",\n \"= [\\\"DECODE({}\\\"] text_info = \\\"\\\\n\\\" for k in range(len(distinct_elements)): expr\",\n \"= \\\"DECODE({}, '{}', 1, 0)\\\".format( \\\"{}\\\", str(distinct_elements[k]).replace(\\\"'\\\", \\\"''\\\") ) transformations\",\n \"\\\\ \\\\____ \\\\ \\\\ \\\\_\\\\ \\\\ \\\\ \\\\ \\\\-./\\\\ \\\\\",\n \"value of the record is greater than the threshold, it\",\n \"aggregations. \\\"\\\"\\\" return self.aggregate([\\\"aad\\\"]).values[self.alias][0] # ---# def abs(self): \\\"\\\"\\\" ---------------------------------------------------------------------------\",\n \"mad : median absolute deviation max : maximum mean :\",\n \"---------- threshold: float, optional Uses the Gaussian distribution to identify\",\n \"\\\"round\\\"): expr = \\\"{}({})\\\".format(func.upper(), \\\"{}\\\") else: expr = \\\"{}({}, {})\\\".format(func.upper(),\",\n \"\\\"float\\\"): trans = ( \\\"'[' || FLOOR({} / {}) *\",\n \"instead of the 'alpha' parameter. alpha: float, optional Number representing\",\n \"Absolute Deviation). Returns ------- float aad See Also -------- vDataFrame.aggregate\",\n \"generated SQL code. Note: Dropping a vColumn can make the\",\n \"self.isnum() else \\\"topk\\\", nbins=nbins, k=nbins, new_category=\\\"Others\\\", return_enum_trans=True, )[0].replace(\\\"{}\\\", self.alias) query\",\n \"(1 meaning global outlier). \\\"\\\"\\\" check_types( [ (\\\"alpha\\\", alpha, [int,\",\n \"parameters = model.get_params() try: model.fit(tmp_view_name, [self.alias], response) query = [\",\n \"to use to determine if the vColumn will be considered\",\n \"vColumn with Label Encoding. vDataFrame[].get_dummies : Encodes the vColumn with\",\n \"int, optional Number of elements to display. Returns ------- tablesample\",\n \"\\\"float\\\", \\\"float\\\", ) ] if method != \\\"robust_zscore\\\": max_floor =\",\n \"vColumns 1 and 2 bars. It is only valid if\",\n \"] ) method = method.lower() assert (method != \\\"cat_stats\\\") or\",\n \"\\\".\\\" ) return self.parent one_hot_encode = get_dummies # ---# def\",\n \"+ sys.getsizeof(self.alias) + sys.getsizeof(self.transformations) + sys.getsizeof(self.catalog) ) for elem in\",\n \"except in compliance with the License. # You may obtain\",\n \"- sauv[\\\"approx_50%\\\"]) / ( 1.4826 * sauv[\\\"mad\\\"] ) elif method\",\n \"'unique' (cardinality). Parameters ---------- approx: bool, optional If set to\",\n \"NULL GROUP BY 1) x ORDER BY verticapy_agg DESC\\\".format( self.alias,\",\n \"{ \\\"index\\\": [item[0] for item in result], \\\"count\\\": [int(item[1]) for\",\n \"to the input vColumn. \\\"\\\"\\\" check_types([(\\\"n\\\", n, [int, float])]) return\",\n \"FROM {} LIMIT 1\\\".format( cmax, cmin, self.parent.__genSQL__() ), print_time_sql=False, )\",\n \"\\\"percent\\\": [float(round(item[2], 3)) for item in result], } return tablesample(values)\",\n \"Encodes the vColumn using the mean encoding of a response.\",\n \"{} was transformed using a mean encoding with {} as\",\n \"= False ): \\\"\\\"\\\" --------------------------------------------------------------------------- Normalizes the input vColumns using\",\n \"/ WEEK / YEAR Returns ------- vDataFrame self.parent See Also\",\n \"= \\\"{}({})\\\".format(func.upper(), \\\"{}\\\") else: expr = \\\"{}({}, {})\\\".format(func.upper(), \\\"{}\\\", x)\",\n \"a numerical value\\\" ) lower_when = ( \\\"WHEN {} <\",\n \"[trans] sauv = {} for elem in self.catalog: sauv[elem] =\",\n \"max_cardinality, [int, float]), (\\\"h\\\", h, [int, float]), (\\\"nbins\\\", nbins, [int,\",\n \"= 10): \\\"\\\"\\\" --------------------------------------------------------------------------- Computes the Information Value (IV) /\",\n \"a function to the vColumn. \\\"\\\"\\\" check_types( [ ( \\\"func\\\",\",\n \"Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].fill_outliers : Fills\",\n \"\\\"backfill\\\"]: all_partition += [elem for elem in order_by] for elem\",\n \"of the record is greater than the threshold, it will\",\n \"vColumn {} was converted to {}.\\\".format( self.alias, dtype ) )\",\n \") if distinct_count > max_cardinality: query += ( \\\"UNION ALL\",\n \"return self.describe(method=\\\"categorical\\\", max_cardinality=k) # ---# def var(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates\",\n \"/ self.parent.shape()[0] ) except: pass total = int(total) conj =\",\n \"based on an aggregation. \\\"\\\"\\\" check_types( [ (\\\"method\\\", method, [str]),\",\n \"int): \\\"\\\"\\\" --------------------------------------------------------------------------- Rounds the vColumn by keeping only the\",\n \"\\\"second\\\", start: bool = True): \\\"\\\"\\\" --------------------------------------------------------------------------- Slices and transforms\",\n \"UNION ALL \\\".join(query), nbins - 1 ) result = executeSQL(\",\n \"= executeSQL( query, title=\\\"Computing the different aggregations.\\\", method=\\\"fetchall\\\", ) for\",\n \"if approx: return self.aggregate(func=[\\\"approx_unique\\\"]).values[self.alias][0] else: return self.aggregate(func=[\\\"unique\\\"]).values[self.alias][0] # ---# def\",\n \") if use_threshold: result = self.aggregate(func=[\\\"std\\\", \\\"avg\\\"]).transpose().values p_alpha, p_1_alpha =\",\n \"step)) # ---# def sub(self, x: float): \\\"\\\"\\\" --------------------------------------------------------------------------- Subtracts\",\n \"CONDITIONS OF ANY KIND, either express or implied. # See\",\n \"+= [\\\"\\\"] result.values[\\\"iv\\\"] += [sum(result[\\\"iv\\\"])] return result # ---# def\",\n \"must be numerical for Normalization\\\") return self.parent # ---# def\",\n \"n: int = 10): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns the n largest\",\n \"One-Hot Encoding. vDataFrame[].mean_encode : Encodes the vColumn using the mean\",\n \"Computes the vDataFrame input aggregations. \\\"\\\"\\\" check_types([(\\\"x\\\", x, [int, float],\",\n \"optional Method to use to normalize. zscore : Normalization using\",\n \"tmp_query += ( \\\" WHERE {} IS NULL\\\".format(self.alias) if (category\",\n \"\\\"text\\\") if return_enum_trans: return trans else: self.transformations += [trans] sauv\",\n \"cube root ceil : value up to the next whole\",\n \"date-like vColumns.\\\" ) assert len(breaks) >= 2, ParameterError( \\\"Length of\",\n \"= 1 self.parent.__add_to_history__( \\\"[Normalize]: The vColumn '{}' was normalized with\",\n \"{} END)\\\".format(lower_when, upper_when, \\\"{}\\\") self.apply(func=func) return self.parent # ---# def\",\n \"Parameters ---------- lower: float, optional Lower bound. upper: float, optional\",\n \"See Also -------- vDataFrame[].dropna : Drops the vColumn missing values.\",\n \"FROM {}) VERTICAPY_OPTIMAL_H_TABLE\\\".format( min_date, self.alias, self.alias, self.parent.__genSQL__() ) query =\",\n \"6, h: float = 0, pie_type: str = \\\"auto\\\", ax=None,\",\n \"Iterable from typing import Union # VerticaPy Modules import verticapy\",\n \"with Label Encoding. vDataFrame[].mean_encode : Encodes the vColumn using the\",\n \"[int, float]), (\\\"dropna\\\", dropna, [bool])]) topk = \\\"\\\" if (k\",\n \"discretization\\\" ) total, query, nth_elems = nb, [], [] while\",\n \"warning_message = \\\"The vColumn {} has no mode (only missing\",\n \"Method to use to normalize. zscore : Normalization using the\",\n \"parameter 'x' will represent the number of seconds, otherwise it\",\n \"\\\"biserial\\\": {}, \\\"regr_avgx\\\": {}, \\\"regr_avgy\\\": {}, \\\"regr_count\\\": {}, \\\"regr_intercept\\\": {},\",\n \"be computed. nbins: int, optional Number of bins used for\",\n \"({3}{4} USING PARAMETERS percentile = 0.75) AS 'approx_75%', APPROXIMATE_PERCENTILE ({3}{4}\",\n \"TypeError(\\\"The vColumn must be numerical for Normalization\\\") return self.parent #\",\n \"return pre_comp assert n >= 1, ParameterError(\\\"Parameter 'n' must be\",\n \"[str]), (\\\"start_date\\\", start_date, [str, datetime.datetime, datetime.date]), (\\\"end_date\\\", end_date, [str, datetime.datetime,\",\n \"(schema): schema = \\\"public\\\" name = gen_tmp_name(schema=schema, name=\\\"kde\\\") if isinstance(xlim,\",\n \"optimized histogram nbins using Random Forest.\\\", method=\\\"fetchall\\\", ) result =\",\n \"Mean for the numerical and Mode for the categorical vColumns.\",\n \"as st return self.apply(func=st.decode(str_sql(\\\"{}\\\"), *argv)) # ---# def density( self,\",\n \"transformed. Parameters ---------- pat: str regular expression. Returns ------- vDataFrame\",\n \"not selecting it in the final generated SQL code. Note:\",\n \"is forbidden !\\\") return self.apply(func=\\\"{} / ({})\\\".format(\\\"{}\\\", x)) # ---#\",\n \"\\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using 'unique' (cardinality). Parameters ----------\",\n \"boxplot(self, by, h, max_cardinality, cat_priority, ax=ax, **style_kwds) # ---# def\",\n \"Diaconis and Sturges. freedman_diaconis : Freedman Diaconis [2 * IQR\",\n \"the vColumn missing values. \\\"\\\"\\\" if isinstance(by, str): by =\",\n \"Verifies if the regular expression is in each of the\",\n \"\\\"({} - {}) / {}({})\\\".format( self.alias, avg, \\\"NULLIFZERO\\\" if (nullifzero)\",\n \"expression in each record of the vColumn. vDataFrame[].extract : Extracts\",\n \"\\\"\\\"\\\" --------------------------------------------------------------------------- Applies a function to the vColumn. Parameters ----------\",\n \"it is part of the DB version you are using.\",\n \"'Others'. cat_priority: list, optional List of the different categories to\",\n \"the vColumn category is date. vDataFrame[].isnum : Returns True if\",\n \"the comma. Parameters ---------- n: int Number of digits to\",\n \"vColumn {} named {} was added to the vDataFrame.\\\".format( self.alias,\",\n \"information, see utilities.tablesample. See Also -------- vDataFrame.aggregate : Computes the\",\n \"AS percent, AVG({3}{4}) AS mean, STDDEV({3}{4}) AS std, MIN({3}{4}) AS\",\n \"True if the vColumn is numerical. See Also -------- vDataFrame[].isbool\",\n \"int, optional Number of elements to display. offset: int, optional\",\n \"(\\\"AVG({}) OVER (PARTITION BY {})\\\".format(response, \\\"{}\\\"), \\\"int\\\", \\\"float\\\") ] self.parent.__update_catalog__(erase=True,\",\n \"self.parent.__get_catalog_value__(self.alias, \\\"store_usage\\\") if pre_comp != \\\"VERTICAPY_NOT_PRECOMPUTED\\\": return pre_comp store_usage =\",\n \"format = 'tabular'))\\\".format( tmp_model_name, i ) for i in range(parameters[\\\"n_estimators\\\"])\",\n \"> 0.01: h = round(h, 2) elif h > 0.0001:\",\n \"vColumn. The vColumn will be transformed. Parameters ---------- start: int\",\n \"= method.lower() self.parent.are_namecols_in([elem for elem in order_by] + by) by\",\n \"\\\\ / # \\\\ / # \\\\/ # _ #\",\n \"n ** (1 / 3)] sturges : Sturges [CEIL(log2(n)) +\",\n \"of the slicing. Returns ------- vDataFrame self.parent See Also --------\",\n \"( self.alias.replace('\\\"', \\\"\\\") + prefix_sep.replace('\\\"', \\\"_\\\") if not (prefix) else\",\n \"executeSQL( query=query, title=\\\"Computing the equal frequency histogram bins.\\\", method=\\\"fetchall\\\", )\",\n \"Parameters ---------- threshold: float, optional Uses the Gaussian distribution to\",\n \"in (\\\"ffill\\\", \\\"pad\\\")) else \\\" DESC\\\" partition_by = ( \\\"PARTITION\",\n \"float A float between 0 and 1 that represents the\",\n \"cat_priority, ax=ax, **style_kwds) # ---# def category(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns\",\n \"except Exception as e: raise QueryError( \\\"{}\\\\nError when applying the\",\n \"str(int(n)) if isinstance(top, decimal.Decimal): top = float(top) self.parent.__update_catalog__( {\\\"index\\\": [\\\"top{}\\\".format(n)],\",\n \"together to create a new category : 'Others'. cat_priority: list,\",\n \"floor_end ), \\\"varchar\\\", \\\"text\\\", ) else: trans = (\\\"FLOOR({}) ||\",\n \"to the vDataFrame.\\\".format( self.alias, name ) ) return self.parent #\",\n \"for k in range(max_floor): self.parent[copy_name].transformations += [ (\\\"{}\\\", self.ctype(), self.category())\",\n \"Interpolation). ffill : Propagation of the first element (Constant Interpolation).\",\n \"empty, an optimized number of bins will be computed. h:\",\n \"---# def __setattr__(self, attr, val): self.__dict__[attr] = val # #\",\n \"COUNT(*) AS count\\\" \\\" FROM vdf_table WHERE {0} IS NOT\",\n \"executeSQL( \\\"SELECT * FROM {} LIMIT 10\\\".format( self.parent.__genSQL__(force_columns=force_columns) ), print_time_sql=False,\",\n \"[(\\\"method\\\", method, [\\\"sturges\\\", \\\"freedman_diaconis\\\", \\\"fd\\\", \\\"auto\\\"])] ) method = method.lower()\",\n \"result[i][2] == None: pass elif math.isnan(result[i][2]): result[i][2] = None avg\",\n \"\\\"''\\\")) if elem[0] != None else \\\"NULL\\\", elem[2] if elem[2]\",\n \"vDataFrame[].discretize : Discretizes the vColumn. vDataFrame[].label_encode : Encodes the vColumn\",\n \"\\\"\\\"\\\" check_types([(\\\"name\\\", name, [str])]) name = quote_ident(name.replace('\\\"', \\\"_\\\")) assert name.replace('\\\"',\",\n \"logarithm log : logarithm log10 : base 10 logarithm mod\",\n \"MINUTE / MONTH / QUARTER / SECOND / TIME ZONE\",\n \"order the data\\\" ) desc = \\\"\\\" if (method in\",\n \"the vColumn. Parameters ---------- threshold: float, optional Uses the Gaussian\",\n \"normalize {} using a Z-Score - The Standard Deviation is\",\n \"if the vColumn is numerical. \\\"\\\"\\\" return self.category() == \\\"date\\\"\",\n \"the vDataFrame by using an advanced analytical function on a\",\n \"/ / # \\\\ / # \\\\ / # \\\\/\",\n \": base 10 logarithm mod : remainder of a division\",\n \"op1, close_l = \\\"<\\\", \\\"]\\\" if labels: label = labels[idx]\",\n \"to impute the missing values. auto : Mean for the\",\n \"else \\\"\\\" ) func = \\\"(CASE {}{}ELSE {} END)\\\".format(lower_when, upper_when,\",\n \"NULLS) OVER ({} ORDER BY {}))\\\".format( \\\"{}\\\", \\\"{}\\\", partition_by, order_by_ts\",\n \"p_1_alpha = ( -threshold * result[\\\"std\\\"][0] + result[\\\"avg\\\"][0], threshold *\",\n \"skewness See Also -------- vDataFrame.aggregate : Computes the vDataFrame input\",\n \"response: str Response vColumn. Returns ------- vDataFrame self.parent See Also\",\n \"--------------------------------------------------------------------------- Returns the tail of the vColumn. Parameters ---------- limit:\",\n \"self.parent.__add_to_history__( \\\"[Fillna]: {} {} missing value{} filled.\\\".format( total, self.alias, conj,\",\n \"vColumn outliers using the input method. \\\"\\\"\\\" check_types([(\\\"lower\\\", lower, [float,\",\n \"type numeric|date\\\" ) if self.isnum(): result = ( self.parent.describe( method=\\\"numerical\\\",\",\n \"- {}) / {} < {}\\\".format( self.alias, result[\\\"avg\\\"][0], result[\\\"std\\\"][0], threshold\",\n \"copy. Returns ------- vDataFrame self.parent See Also -------- vDataFrame.eval :\",\n \"Parameters ---------- method: str, optional Method to use to fill\",\n \") except: cmax, cmin = ( \\\"MAX({}) OVER (PARTITION BY\",\n \"> 0: try: if \\\"count\\\" in sauv: self.catalog[\\\"count\\\"] = int(sauv[\\\"count\\\"])\",\n \"< 0: index_start += self.parent.shape()[0] if isinstance(index_stop, int): if index_stop\",\n \"See Also -------- vDataFrame[].bar : Draws the Bar Chart of\",\n \"auto : Uses method 'same_width' for numerical vColumns, cast the\",\n \"the vColumn based on an aggregation. \\\"\\\"\\\" check_types( [ (\\\"method\\\",\",\n \"0: column = args[0] elif \\\"column\\\" in kwargs: column =\",\n \"# |_)\\\\/ |_)(_|(_|| \\\\_/|_|(_||| # / # ____________ ______ #\",\n \"lower and upper outliers.\\\".format( self.alias ), method=\\\"fetchall\\\", ) ] if\",\n \"max_cardinality ) if distinct_count > max_cardinality: query += ( \\\"UNION\",\n \"isinstance(values[elem][i], decimal.Decimal): values[elem][i] = float(values[elem][i]) return tablesample(values) # ---# def\",\n \"self.alias), self.alias, kwargs[\\\"agg\\\"], self.parent.__genSQL__(), self.alias, ) query_result = executeSQL( query=query,\",\n \"h, donut, rose, ax=None, **style_kwds, ) # ---# def plot(\",\n \"vColumn using a time series rule. \\\"\\\"\\\" return self.apply(func=\\\"DATE_PART('{}', {})\\\".format(field,\",\n \"See Also -------- vDataFrame.bar : Draws the Bar Chart of\",\n \"to use this method when first preparing your data. Parameters\",\n \"\\\"SELECT {} AS {} FROM {}{} LIMIT {} OFFSET {}\\\".format(\",\n \"method, [\\\"auto\\\", \\\"smart\\\", \\\"same_width\\\", \\\"same_freq\\\", \\\"topk\\\"], ), (\\\"return_enum_trans\\\", return_enum_trans, [bool]),\",\n \"= fd else: best_h = max(sturges, fd) self.parent.__update_catalog__({\\\"index\\\": [\\\"numh\\\"], self.alias:\",\n \"vDataFrame.analytic : Adds a new vColumn to the vDataFrame by\",\n \"if not (schema): schema = \\\"public\\\" name = gen_tmp_name(schema=schema, name=\\\"kde\\\")\",\n \"IS NOT NULL\\\".format(self.alias) if (dropna) else \\\"\\\" query = \\\"SELECT\",\n \"result.values[\\\"iv\\\"] += [sum(result[\\\"iv\\\"])] return result # ---# def kurtosis(self): \\\"\\\"\\\"\",\n \"self.aggregate([\\\"avg\\\", \\\"std\\\"]).values[self.alias] if stddev == 0: warning_message = \\\"Can not\",\n \"element. See Also -------- vDataFrame.aggregate : Computes the vDataFrame input\",\n \"as categorical (No h will be picked or computed) nbins:\",\n \"can not be converted to {}\\\".format( e, self.alias, dtype )\",\n \"sauv[\\\"mad\\\"] ) elif method == \\\"zscore\\\": self.catalog[elem] = (sauv[elem] -\",\n \"the vColumn. Returns ------- str/float/int vColumn nth most occurent element.\",\n \"from the vDataFrame. \\\"\\\"\\\" check_types([(\\\"add_history\\\", add_history, [bool])]) try: parent =\",\n \"';' || (FLOOR({} / {}) * {} + {}{}) ||\",\n \"{} AS {} FROM {} WHERE {} IS NOT NULL\",\n \"to determine if the vColumn will be considered as categorical.\",\n \"---------- y: str Response vColumn. nbins: int, optional Maximum number\",\n \"nullifzero = 0 cmin, cmax = self.aggregate([\\\"min\\\", \\\"max\\\"]).values[self.alias] if cmax\",\n \"Returns ------- ax Matplotlib axes object See Also -------- vDataFrame[].bar\",\n \"expression in each record of the vColumn. The vColumn will\",\n \"vDataFrame represents the entire relation, a vColumn can be seen\",\n \"optimised interval will be computed. nbins: int, optional Number of\",\n \"by: self.parent.are_namecols_in(by) by = self.parent.format_colnames(by) from verticapy.plot import boxplot return\",\n \"datetime.datetime, datetime.date]), (\\\"area\\\", area, [bool]), (\\\"step\\\", step, [bool]), ] )\",\n \"------- vDataFrame self.parent See Also -------- vDataFrame.add_copy : Creates a\",\n \"method in (\\\"same_width\\\", \\\"auto\\\"): if not (h) or h <=\",\n \"\\\"]\\\", \\\"]\\\" else: op1, op2, close_l, close_r = \\\"<=\\\", \\\"<\\\",\",\n \"a copy with the specified name. \\\\u26A0 Warning : SQL\",\n \"--------------------------------------------------------------------------- Returns the n largest vColumn elements. Parameters ---------- n:\",\n \"1) else str(int(n)) if isinstance(top, decimal.Decimal): top = float(top) self.parent.__update_catalog__(\",\n \"input method. Parameters ---------- method: str, optional Method to use\",\n \"be transformed. Parameters ---------- start: int Start of the slicing.\",\n \"# ---# def var(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using\",\n \"float = 0, ax=None, **style_kwds, ): \\\"\\\"\\\" --------------------------------------------------------------------------- Draws the\",\n \"in result if elem[1] != None ] ), ) stddev\",\n \"AS 'approx_25%', APPROXIMATE_PERCENTILE ({3}{4} USING PARAMETERS percentile = 0.5) AS\",\n \"VERTICAPY_SUBTABLE ORDER BY split_value::float\\\".format( \\\" UNION ALL \\\".join(query), nbins -\",\n \"copy will be created using the input Name. Returns -------\",\n \"all_cols, max_floor = self.parent.get_columns(), 0 for column in all_cols: try:\",\n \"Sturges. freedman_diaconis : Freedman Diaconis [2 * IQR / n\",\n \"geopandas.GeoDataFrame.plot.html Returns ------- ax Matplotlib axes object \\\"\\\"\\\" columns =\",\n \"p_1_alpha = executeSQL( query=query, title=\\\"Computing the quantiles of {}.\\\".format(self.alias), method=\\\"fetchrow\\\",\",\n \"be able to solve this issue.\\\" ) self.add_copy(new_name) parent =\",\n \"None), ParameterError( \\\"At least 'lower' or 'upper' must have a\",\n \"------- vDataFrame self.parent See Also -------- vDataFrame.fill_outliers : Fills the\",\n \"value.replace(\\\"'\\\", \\\"''\\\") ) ) # ---# def str_slice(self, start: int,\",\n \"to normalize by grouping by elements, please use a method\",\n \"title=title) # ---# def numh(self, method: str = \\\"auto\\\"): \\\"\\\"\\\"\",\n \": trigonometric inverse cosine asin : trigonometric inverse sine atan\",\n \"vDataFrame[].label_encode : Encodes the vColumn with Label Encoding. vDataFrame[].get_dummies :\",\n \"{} IS NOT NULL ORDER BY {} DESC LIMIT {}\\\".format(\",\n \"1) query = \\\"WITH vdf_table AS (SELECT * FROM {})\",\n \"using a bijection from the different categories to [0, n\",\n \"Methods # # ---# def aad(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the\",\n \"be binary to use iv_woe.\\\".format(y) ) self.parent[y].distinct() trans = self.discretize(\",\n \"defined Encoding. vDataFrame[].discretize : Discretizes the vColumn. vDataFrame[].label_encode : Encodes\",\n \"_verticapy_row_nb_ FROM {} WHERE {} IS NOT NULL) VERTICAPY_SUBTABLE {}\\\".format(\",\n \"\\\".join(by) ), \\\"STDDEV({}) OVER (PARTITION BY {})\\\".format( self.alias, \\\", \\\".join(by)\",\n \"and upper outliers.\\\".format( self.alias ), method=\\\"fetchall\\\", ) ] if mean_alpha\",\n \"\\\", \\\"_\\\") .replace(\\\"/\\\", \\\"_\\\") .replace(\\\",\\\", \\\"_\\\") .replace(\\\"'\\\", \\\"_\\\") ) expr\",\n \"---------- dtype: str New type. Returns ------- vDataFrame self.parent See\",\n \"def product(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using 'product'. Returns\",\n \"\\\"float\\\": model = RandomForestRegressor(tmp_model_name) else: model = RandomForestClassifier(tmp_model_name) model.set_params({\\\"n_estimators\\\": 20,\",\n \"method == \\\"same_freq\\\": assert nbins >= 2, ParameterError( \\\"Parameter 'nbins'\",\n \"the input vColumn. \\\"\\\"\\\" check_types([(\\\"x\\\", x, [int, float])]) assert x\",\n \"---# def str_contains(self, pat: str): \\\"\\\"\\\" --------------------------------------------------------------------------- Verifies if the\",\n \"is_numeric, is_date = ( self.nunique(), self.isnum(), self.isdate(), ) if (is_date)\",\n \"the vDataFrame. \\\"\\\"\\\" check_types([(\\\"add_history\\\", add_history, [bool])]) try: parent = self.parent\",\n \"You may not use this file except in compliance with\",\n \"aggregation (ex: AVG(column1) + 5). of: str, optional The vColumn\",\n \"ax.set_xlabel(self.alias) return ax kernel = kernel.lower() from verticapy.learn.neighbors import KernelDensity\",\n \"self.parent.filter(\\\"{} IS NOT NULL\\\".format(self.alias)) return self.parent # ---# def fill_outliers(\",\n \"created using the input Name. Returns ------- vDataFrame self.parent See\",\n \": Encodes the vColumn using the mean encoding of a\",\n \"topk = \\\"\\\" if (k < 1) else \\\"LIMIT {}\\\".format(k)\",\n \"values lesser than the lower bound to the lower bound\",\n \"QUARTER / SECOND / TIME ZONE / TIMEZONE_HOUR / TIMEZONE_MINUTE\",\n \"= [elem[0] for elem in result] except: drop(tmp_view_name, method=\\\"view\\\") drop(tmp_model_name,\",\n \"result. For more information, see utilities.tablesample. See Also -------- vDataFrame.iv_woe\",\n \"to partition the data. method: str, optional The method to\",\n \"limit = \\\" LIMIT {}\\\".format(limit) else: limit = \\\"\\\" query\",\n \"\\\"auto\\\"): if not (h) or h <= 0: if nbins\",\n \"{\\\"color\\\": colors[idx % len(colors)]} ax = self.parent.search( \\\"{} = '{}'\\\".format(self.parent[by].alias,\",\n \"aggregation. \\\"\\\"\\\" check_types( [ (\\\"method\\\", method, [str]), (\\\"of\\\", of, [str]),\",\n \"'approx_90%', MAX({3}{4}) AS max FROM vdf_table\\\"\\\"\\\".format( category, self.alias, self.parent.shape()[0], numcol,\",\n \"from verticapy.plot import bar return bar(self, method, of, max_cardinality, nbins,\",\n \"Regular pie chart. donut : Donut chart. rose : Rose\",\n \"missing values. \\\"\\\"\\\" if isinstance(by, str): by = [by] if\",\n \"/ / # / / # \\\\ / # \\\\\",\n \"= \\\"APPROXIMATE_MEDIAN\\\" query = \\\"SELECT {}, {}({}) FROM {} GROUP\",\n \"): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using 'median'. Parameters ----------\",\n \"bool, optional If set to True, the Median will be\",\n \"# Methods # # ---# def aad(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates\",\n \"width bins. smart : Uses the Random Forest on a\",\n \"vDataFrame self.parent See Also -------- vDataFrame[].fill_outliers : Fills the vColumn\",\n \"= True): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using an input\",\n \"item in result], \\\"percent\\\": [float(round(item[2], 3)) for item in result],\",\n \"if mean_1_alpha == None: mean_alpha = \\\"NULL\\\" self.apply( func=\\\"(CASE WHEN\",\n \"median absolute deviation max : maximum mean : average median\",\n \"response column to find the most relevant interval to use\",\n \"self.parent.__genSQL__(), self.parent.__get_last_order_by__(), index_start, limit, ) return vDataFrameSQL(query) elif isinstance(index, int):\",\n \"[str])]) return self.apply( func=\\\"REGEXP_REPLACE({}, '{}', '{}')\\\".format( \\\"{}\\\", to_replace.replace(\\\"'\\\", \\\"''\\\"), value.replace(\\\"'\\\",\",\n \"k in range(len(distinct_elements) - n): name = ( '\\\"{}{}\\\"'.format(prefix, k)\",\n \"self.catalog = { \\\"cov\\\": {}, \\\"pearson\\\": {}, \\\"spearman\\\": {}, \\\"spearmand\\\":\",\n \"= [], ax=None, **style_kwds, ): \\\"\\\"\\\" --------------------------------------------------------------------------- Draws the box\",\n \"Size of the slicing. Returns ------- vDataFrame self.parent See Also\",\n \"def quantile(self, x: float, approx: bool = True): \\\"\\\"\\\" ---------------------------------------------------------------------------\",\n \"(\\\"start_date\\\", start_date, [str, datetime.datetime, datetime.date]), (\\\"end_date\\\", end_date, [str, datetime.datetime, datetime.date]),\",\n \"AS events FROM ({}) x GROUP BY 1\\\".format( self.alias, y,\",\n \"vDataFrame self.parent See Also -------- vDataFrame[].apply : Applies a function\",\n \"Plot. Parameters ---------- by: str, optional vColumn to use to\",\n \"), bin_spatial_to_str(self.category()), new_category.replace(\\\"'\\\", \\\"''\\\"), ), \\\"varchar\\\", \\\"text\\\", ) elif self.isnum()\",\n \"item[0] for item in executeSQL( query=query, title=\\\"Computing the average of\",\n \"\\\"DECODE({}, NULL, 0, 1)\\\" elif method in (\\\"mean\\\", \\\"avg\\\", \\\"median\\\"):\",\n \"len(colors)]} ax = self.parent.search( \\\"{} = '{}'\\\".format(self.parent[by].alias, column) )[self.alias].density( bandwidth=bandwidth,\",\n \"quantile(1-alpha) will be filled. Returns ------- vDataFrame self.parent See Also\",\n \"FROM {}) {}\\\".format( self.parent.__genSQL__(), \\\" UNION ALL \\\".join(query) ) title\",\n \"def category(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns the category of the vColumn.\",\n \"the vColumn outliers using the input method. \\\"\\\"\\\" check_types([(\\\"lower\\\", lower,\",\n \"input vColumn. \\\"\\\"\\\" check_types([(\\\"x\\\", x, [int, float])]) assert x !=\",\n \"except: ctype = get_data_types( \\\"SELECT {} AS apply_test_feature FROM {}\",\n \"return self.apply(func=\\\"{} * ({})\\\".format(\\\"{}\\\", x)) # ---# def nlargest(self, n:\",\n \"when first preparing your data. Parameters ---------- new_name: str The\",\n \"was filled.\\\") self.transformations = [elem for elem in copy_trans] for\",\n \"= vColumn( name, parent=self.parent, transformations=[item for item in self.transformations], catalog=self.catalog,\",\n \"in enumerate(result): result[idx][0] = ( \\\"NULL\\\" if (elem[0] == None)\",\n \"AS percent FROM {}{} GROUP BY {} ORDER BY _verticapy_cnt_\",\n \"by applicable law or agreed to in writing, software #\",\n \"vDataFrame.aggregate : Computes the vDataFrame input aggregations. \\\"\\\"\\\" return self.aggregate([\\\"sum\\\"]).values[self.alias][0]\",\n \"in result] except: drop(tmp_view_name, method=\\\"view\\\") drop(tmp_model_name, method=\\\"model\\\") raise drop(tmp_view_name, method=\\\"view\\\")\",\n \"is date like). The vColumn will be transformed. Parameters ----------\",\n \"of bins. If empty, an optimized number of bins will\",\n \") .transpose() .values[self.alias] ) count, vColumn_min, vColumn_025, vColumn_075, vColumn_max =\",\n \"[bool]), ] ) self.parent.are_namecols_in(ts) ts = self.parent.format_colnames(ts) from verticapy.plot import\",\n \"represents the quantile. For example: 0.25 represents Q1. approx: bool,\",\n \"If this parameter is equal to 0, an optimised interval\",\n \"axes object See Also -------- vDataFrame.boxplot : Draws the Box\",\n \"-------- vDataFrame[].dropna : Drops the vColumn missing values. \\\"\\\"\\\" if\",\n \"NOT NULL) VERTICAPY_SUBTABLE {}\\\".format( self.alias, self.alias, self.alias, self.parent.__genSQL__(), self.alias, where,\",\n \"machine learning features. It supports the # entire data science\",\n \"is available only if the parameter 'by' is empty\\\\nIf you\",\n \"to transform the vColumn. abs : absolute value acos :\",\n \"(\\\"figsize\\\" in kwargs): kwargs[\\\"figsize\\\"] = (14, 10) return self.parent[columns].to_geopandas(self.alias).plot(*args, **kwargs)\",\n \"to replace. value: str, optional New value. Returns ------- vDataFrame\",\n \"self.apply(func=\\\"{} - ({})\\\".format(\\\"{}\\\", x)) # ---# def sum(self): \\\"\\\"\\\" ---------------------------------------------------------------------------\",\n \"global outlier). \\\"\\\"\\\" if isinstance(method, str): method = method.lower() check_types(\",\n \"most occurent elements, how often they occur, and other statistical\",\n \"Store Usage of the vColumn {}.\\\".format(self.alias), method=\\\"fetchfirstelem\\\", ) self.parent.__update_catalog__( {\\\"index\\\":\",\n \"to partition the data. h: float, optional Interval width if\",\n \") mean_alpha, mean_1_alpha = [ item[0] for item in executeSQL(\",\n \"minimum mode : most occurent element percent : percent of\",\n \"Quantile of the vColumn 'of' (ex: 50% to get the\",\n \"a specific vColumn. \\\"\\\"\\\" return self.parent.aggregate(func=func, columns=[self.alias]).transpose() agg = aggregate\",\n \"input Name. Returns ------- vDataFrame self.parent See Also -------- vDataFrame.apply\",\n \"\\\\/_____/ \\\\/_____/ \\\\/_____/ \\\\/_/ \\\\/_/ \\\\/_/ \\\\/_/ # # #\",\n \"feature{}created: {}\\\".format( self.alias, len(all_new_features), conj, \\\", \\\".join(all_new_features) ) + \\\".\\\"\",\n \"def add(self, x: float): \\\"\\\"\\\" --------------------------------------------------------------------------- Adds the input element\",\n \"verticapy.toolbox import * from verticapy.errors import * ## # #\",\n \"non-Missing elements). Returns ------- int number of non-Missing elements. See\",\n \"sauv[\\\"max\\\"] - sauv[\\\"min\\\"] ) except: pass if method == \\\"robust_zscore\\\":\",\n \"index_start < 0: index_start += self.parent.shape()[0] if isinstance(index_stop, int): if\",\n \"the computation. Returns ------- tablesample An object containing the result.\",\n \"of nbins. If empty, an optimized number of nbins will\",\n \"to the input vColumn. \\\"\\\"\\\" return self.apply(func=\\\"ABS({})\\\") # ---# def\",\n \"**kwargs): \\\"\\\"\\\" --------------------------------------------------------------------------- Draws the Geospatial object. Parameters ---------- *args\",\n \"func=\\\"(CASE WHEN ({} BETWEEN {} AND {}) THEN {} ELSE\",\n \"verticapy.learn.neighbors import KernelDensity schema = verticapy.options[\\\"temp_schema\\\"] if not (schema): schema\",\n \"alias, str : vColumn alias. catalog, dict : Catalog of\",\n \"number of decimal places sign : arithmetic sign sin :\",\n \"\\\"topk\\\", nbins=nbins, k=nbins, new_category=\\\"Others\\\", return_enum_trans=True, )[0].replace(\\\"{}\\\", self.alias) query = \\\"SELECT\",\n \"statistical information. Parameters ---------- k: int, optional Number of most\",\n \"float): \\\"\\\"\\\" --------------------------------------------------------------------------- Adds the input element to the vColumn.\",\n \"by, [list]), (\\\"order_by\\\", order_by, [list]), ] ) method = method.lower()\",\n \"'{}', '{}')\\\".format( \\\"{}\\\", to_replace.replace(\\\"'\\\", \\\"''\\\"), value.replace(\\\"'\\\", \\\"''\\\") ) ) #\",\n \"max). (x - min) / (max - min) by: list,\",\n \"---------- method: str, optional Method to use to compute the\",\n \"only available on type numeric|date\\\" ) if self.isnum(): result =\",\n \"k: int, optional The integer k of the 'topk' method.\",\n \"using a Robust Z-Score - The MAD is null !\\\".format(\",\n \"be > 1) Returns ------- tablesample An object containing the\",\n \"if the regular expression is in each of the vColumn\",\n \"pie_type, [\\\"auto\\\", \\\"donut\\\", \\\"rose\\\"]), ] ) donut = True if\",\n \"will be picked or computed) h: float, optional Interval width\",\n \"): \\\"\\\"\\\" --------------------------------------------------------------------------- Draws the box plot of the vColumn.\",\n \"the creation of correlated features. use_numbers_as_suffix: bool, optional Uses numbers\",\n \"alias {name}.\\\\nBy changing the parameter 'name', you'll be able to\",\n \"[str]), (\\\"max_cardinality\\\", max_cardinality, [int, float]), (\\\"h\\\", h, [int, float]), (\\\"nbins\\\",\",\n \"drastically decrease. Returns ------- int vColumn cardinality (or approximate cardinality).\",\n \"vDataFrame[].get_dummies : Encodes the vColumn with One-Hot Encoding. vDataFrame[].mean_encode :\",\n \"frequency histogram bins.\\\", method=\\\"fetchall\\\", ) result = [elem[0] for elem\",\n \"categories to consider when drawing the box plot. The other\",\n \"self.alias, self.parent.shape()[0], numcol, cast, ) tmp_query += ( \\\" WHERE\",\n \"It can also be a cutomized aggregation (ex: AVG(column1) +\",\n \") ] else: warning_message = \\\"Can not normalize {} using\",\n \"was transformed with the func 'x -> {}'.\\\".format( copy_name.replace('\\\"', \\\"\\\"),\",\n \"by using an advanced analytical function on a specific vColumn.\",\n \"= \\\"SELECT {} AS {} FROM {} WHERE {} IS\",\n \"has already the alias {name}.\\\\nBy changing the parameter 'name', you'll\",\n \"is set to 'cat_stats'. Returns ------- tablesample An object containing\",\n \"applicable law or agreed to in writing, software # distributed\",\n \"{}, \\\"regr_intercept\\\": {}, \\\"regr_r2\\\": {}, \\\"regr_slope\\\": {}, \\\"regr_sxx\\\": {}, \\\"regr_sxy\\\":\",\n \"Encodes the vColumn using the average of the response partitioned\",\n \"use this method when first preparing your data. Parameters ----------\",\n \"Returns ------- vDataFrame The vDataFrame of the search. See Also\",\n \"\\\"({} - {}) / ({})\\\".format(\\\"{}\\\", med, mad), \\\"float\\\", \\\"float\\\", )\",\n \"\\\"MIN({}) OVER (PARTITION BY {})\\\".format( self.alias, \\\", \\\".join(by) ), )\",\n \"this \\\" \\\"issue.\\\" ) for k in range(len(distinct_elements) - n):\",\n \"(\\\"use_threshold\\\", use_threshold, [bool]), (\\\"threshold\\\", threshold, [int, float]), ] ) if\",\n \"if n = 1 then this method will return the\",\n \"float(top) self.parent.__update_catalog__( {\\\"index\\\": [\\\"top{}\\\".format(n)], self.alias: [top]} ) return top #\",\n \"pass if method == \\\"robust_zscore\\\": self.catalog[\\\"median\\\"] = 0 self.catalog[\\\"mad\\\"] =\",\n \"trigonometric inverse tangent cbrt : cube root ceil : value\",\n \"\\\"vColumn {} must be binary to use iv_woe.\\\".format(y) ) response_cat\",\n \"\\\"{}\\\", fun, \\\"{}\\\", \\\", \\\".join(by) ) elif method in (\\\"ffill\\\",\",\n \"the vColumn using the mean encoding of a response. \\\"\\\"\\\"\",\n \"right. Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].apply :\",\n \"def dropna(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Filters the vDataFrame where the vColumn\",\n \"self.aggregate([\\\"min\\\"]).values[self.alias][0] # ---# def mode(self, dropna: bool = False, n:\",\n \"result = [distinct_count] + result index = [ \\\"unique\\\", \\\"count\\\",\",\n \"method: str, optional The method to use to aggregate the\",\n \"\\\"same_freq\\\") or ( self.isnum() and method == \\\"smart\\\" ): n\",\n \": cube root ceil : value up to the next\",\n \"if approx else \\\"\\\" return self.aggregate(func=[prefix + \\\"{}%\\\".format(x * 100)]).values[self.alias][\",\n \"optional Prefix of the dummies. prefix_sep: str, optional Prefix delimitor\",\n \"xmin = self.min() xmax = self.max() else: xmin, xmax =\",\n \"optional Number of bins used for the discretization (must be\",\n \"\\\"SELECT {} AS {}, {} AS ord, {}::int AS {}\",\n \"try: if (quote_ident(column) in func) or ( re.search( re.compile(\\\"\\\\\\\\b{}\\\\\\\\b\\\".format(column.replace('\\\"', \\\"\\\"))),\",\n \"Creates a new feature by evaluating some conditions. vDataFrame[].discretize :\",\n \"True if not (\\\"figsize\\\" in kwargs): kwargs[\\\"figsize\\\"] = (14, 10)\",\n \"# ---# def drop_outliers( self, threshold: float = 4.0, use_threshold:\",\n \"self.distinct() if len(cat) == 1: lp, rp = \\\"(\\\", \\\")\\\"\",\n \"list, optional Labels used to name the new categories. If\",\n \"self, method: str = \\\"zscore\\\", by: list = [], return_trans:\",\n \"<= 0: limit = 0 limit = \\\" LIMIT {}\\\".format(limit)\",\n \"\\\"{}\\\", p_alpha, p_1_alpha, \\\"{}\\\" ) ) elif method == \\\"mean\\\":\",\n \"!\\\".format( self.alias ) warnings.warn(warning_message, Warning) return self elif (n ==\",\n \"'x -> {}' to '{}'\\\".format( e, func.replace(\\\"{}\\\", \\\"x\\\"), self.alias.replace('\\\"', \\\"\\\")\",\n \"int(float(count / int(nbins))) assert nb != 0, Exception( \\\"Not enough\",\n \"else: limit = \\\"\\\" query = \\\"(SELECT {} FROM {}{}\",\n \"ELSE NULL END)\\\".format( \\\"{}\\\", p_alpha, p_1_alpha, \\\"{}\\\" ) ) elif\",\n \"the median). It can also be a cutomized aggregation (ex:\",\n \"otherwise it will represent a number. Returns ------- vDataFrame self.parent\",\n \"acos : trigonometric inverse cosine asin : trigonometric inverse sine\",\n \"vColumn using 'std' (Standard Deviation). Returns ------- float std See\",\n \"# ---# def str_replace(self, to_replace: str, value: str = \\\"\\\"):\",\n \"= KernelDensity( name, bandwidth=bandwidth, kernel=kernel, nbins=nbins, xlim=xlim_tmp, store=False, ) try:\",\n \"vColumn records by an input value. \\\"\\\"\\\" check_types([(\\\"start\\\", start, [int,\",\n \"# ---# def drop(self, add_history: bool = True): \\\"\\\"\\\" ---------------------------------------------------------------------------\",\n \"\\\"Reads {} {} largest elements.\\\".format(self.alias, n) return to_tablesample(query, title=title) #\",\n \"is set to False else the lower and upper ZScores.\",\n \"self.parent.format_colnames(response) assert self.parent[response].isnum(), TypeError( \\\"The response column must be numerical\",\n \"the bar chart of the vColumn based on an aggregation.\",\n \"the upper and lower outliers by their respective average. null\",\n \"\\\"_\\\", drop_first: bool = True, use_numbers_as_suffix: bool = False, ):\",\n \"'{}'\\\".format( bin_spatial_to_str(self.category(), self.alias), category, ) ) query += [lp +\",\n \"!= \\\"robust_zscore\\\": max_floor = 0 for elem in by: if\",\n \"> 0.0001: h = round(h, 4) elif h > 0.000001:\",\n \"[str]), (\\\"value\\\", value, [str])]) return self.apply( func=\\\"REGEXP_REPLACE({}, '{}', '{}')\\\".format( \\\"{}\\\",\",\n \"\\\"sin\\\", \\\"sinh\\\", \\\"sqrt\\\", \\\"tan\\\", \\\"tanh\\\", ], ), (\\\"x\\\", x, [int,\",\n \"using the MinMax (min and max). (x - min) /\",\n \"------- float/str minimum See Also -------- vDataFrame.aggregate : Computes the\",\n \"elif self.isdate(): min_date = self.min() table = \\\"(SELECT DATEDIFF('second', '{}'::timestamp,\",\n \"ctype = get_data_types( \\\"SELECT {} AS apply_test_feature FROM {} WHERE\",\n \"\\\"max\\\"]).values[self.alias] if cmax - cmin == 0: warning_message = \\\"Can\",\n \"== None: warning_message = \\\"The vColumn {} has no mode\",\n \"Encoding. vDataFrame[].mean_encode : Encodes the vColumn using the mean encoding\",\n \"\\\"the parameters ('prefix', 'prefix_sep'), you'll be able to solve this\",\n \"\\\"\\\"\\\" import verticapy.stats as st return self.apply(func=st.decode(str_sql(\\\"{}\\\"), *argv)) # ---#\",\n \"str / date, optional Input End Date. For example, time\",\n \"because of ambiguous columns naming.\\\\nBy changing one of \\\" \\\"the\",\n \"the vColumn database type. \\\"\\\"\\\" return self.transformations[-1][2] # ---# def\",\n \"record is greater than the threshold it will be considered\",\n \"---# def mul(self, x: float): \\\"\\\"\\\" --------------------------------------------------------------------------- Multiplies the vColumn\",\n \"\\\"SELECT {}, ord, non_events, events, non_events / NULLIFZERO(SUM(non_events) OVER ())\",\n \"to find the most relevant interval to use for the\",\n \"Standard Deviation is null !\\\".format( self.alias ) warnings.warn(warning_message, Warning) return\",\n \"to 2 in case of discretization using the method 'smart'.\\\"\",\n \"{} smallest elements.\\\".format(n, self.alias) return to_tablesample(query, title=title) # ---# def\",\n \"f\\\"A vColumn has already the alias of one of the\",\n \"set to True, the lowest element of the list will\",\n \"function variable must be composed of two flower brackets {}.\",\n \"start_or_end ) ) # ---# def spider( self, by: str\",\n \"str = \\\"\\\", start_date: Union[str, datetime.datetime, datetime.date] = \\\"\\\", end_date:\",\n \"else \\\" \\\" result = executeSQL( \\\"SELECT {} FROM (SELECT\",\n \"= \\\"approx_\\\" if approx else \\\"\\\" return self.aggregate(func=[prefix + \\\"{}%\\\".format(x\",\n \"float]), (\\\"h\\\", h, [int, float]), (\\\"nbins\\\", nbins, [int, float]), ]\",\n \"1] if right: op1, op2, close_l, close_r = \\\"<\\\", \\\"<=\\\",\",\n \") if by: self.parent.are_namecols_in(by) by = self.parent.format_colnames(by) from verticapy.plot import\",\n \"(self.max() - self.min()) * 1.01 / nbins if h >\",\n \"\\\"cos\\\", \\\"cosh\\\", \\\"cot\\\", \\\"exp\\\", \\\"floor\\\", \\\"ln\\\", \\\"log\\\", \\\"log10\\\", \\\"mod\\\", \\\"pow\\\",\",\n \"THEN {} \\\".format(\\\"{}\\\", lower, lower) if (isinstance(lower, (float, int))) else\",\n \"vColumn. Parameters ---------- x: float If the vColumn type is\",\n \"print(\\\"{} element{}filled.\\\".format(total, conj)) self.parent.__add_to_history__( \\\"[Fillna]: {} {} missing value{} filled.\\\".format(\",\n \"--------------------------------------------------------------------------- Aggregates the vColumn using 'unique' (cardinality). Parameters ---------- approx:\",\n \"is numerical, False otherwise. Returns ------- bool True if the\",\n \"only the input number of digits after the comma. Parameters\",\n \"element to use to order the data\\\" ) desc =\",\n \"expr: new_column = \\\"COALESCE({}, {})\\\".format(\\\"{}\\\", expr) elif method == \\\"0ifnull\\\":\",\n \"The vColumn will be transformed. Parameters ---------- pat: str Regular\",\n \"str = \\\"auto\\\", max_cardinality: int = 6, numcol: str =\",\n \"bandwidth, [int, float]), (\\\"nbins\\\", nbins, [float, int]), ] ) if\",\n \"self elif (n == 1) and (self.parent[by[0]].nunique() < 50): try:\",\n \"\\\"[AsType]: The vColumn {} was converted to {}.\\\".format( self.alias, dtype\",\n \"count = self.count() nb = int(float(count / int(nbins))) assert nb\",\n \"{} WHERE {} IS NOT NULL LIMIT 20\\\".format( self.alias, dtype,\",\n \"int]), ] ) if by: self.parent.are_namecols_in(by) by = self.parent.format_colnames(by) from\",\n \"boolean, False otherwise. Returns ------- bool True if the vColumn\",\n \"GROUP (ORDER BY {}) OVER () FROM {} LIMIT 1\\\".format(\",\n \"self.max() else: xmin, xmax = xlim custom_lines = [] columns\",\n \"\\\"[\\\", \\\"[\\\" if idx == 0 and include_lowest: op1, close_l\",\n \"the computation. cat_stats : Computes statistics of a numerical column\",\n \"(self.parent.is_colname_in(new_name)), NameError( f\\\"A vColumn has already the alias {new_name}.\\\\nBy changing\",\n \"self.topk(k).values[\\\"index\\\"] trans = ( \\\"(CASE WHEN {} IN ({}) THEN\",\n \"self.alias, self.alias, p_alpha, self.alias, self.alias, p_1_alpha, ) mean_alpha, mean_1_alpha =\",\n \"by the NULL value. winsorize : Clips the vColumn using\",\n \"Matplotlib axes object See Also -------- vDataFrame.donut : Draws the\",\n \"ax.set_title(\\\"KernelDensity\\\") ax.legend( custom_lines, columns, title=by, loc=\\\"center left\\\", bbox_to_anchor=[1, 0.5], )\",\n \"{} IS NULL\\\".format(self.alias) if (category in (\\\"None\\\", None)) else \\\"\",\n \"- {}) / {}({} - {})\\\".format( self.alias, cmin, \\\"NULLIFZERO\\\" if\",\n \"), \\\"apply_test_feature\\\", ) category = get_category_from_vertica_type(ctype=ctype) all_cols, max_floor = self.parent.get_columns(),\",\n \"# ---# def fill_outliers( self, method: str = \\\"winsorize\\\", threshold:\",\n \"[int, float])]) return self.apply(func=\\\"ROUND({}, {})\\\".format(\\\"{}\\\", n)) # ---# def sem(self):\",\n \") return self.parent # ---# def mad(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates\",\n \"\\\"MAX({}) OVER (PARTITION BY {})\\\".format( self.alias, \\\", \\\".join(by) ), \\\"MIN({})\",\n \"): \\\"\\\"\\\" --------------------------------------------------------------------------- Drops outliers in the vColumn. Parameters ----------\",\n \"the vColumn. labels: list, optional Labels used to name the\",\n \"Returns ------- float/str minimum See Also -------- vDataFrame.aggregate : Computes\",\n \"---# def bar( self, method: str = \\\"density\\\", of: str\",\n \"percent of non-missing elements q% : q quantile (ex: 50%\",\n \": Applies a function to all the vColumns. vDataFrame.eval :\",\n \"greater or equal to 1\\\") where = \\\" WHERE {}\",\n \"or parameter 'labels' must be empty.\\\" ) conditions, column =\",\n \"if verticapy.options[\\\"print_info\\\"]: print(\\\"{} element{}filled.\\\".format(total, conj)) self.parent.__add_to_history__( \\\"[Fillna]: {} {} missing\",\n \"0: try: if \\\"count\\\" in sauv: self.catalog[\\\"count\\\"] = int(sauv[\\\"count\\\"]) +\",\n \"\\\", \\\".join(by) ), ) if return_trans: return \\\"({} - {})\",\n \"(\\\"by\\\", by, [list]), (\\\"order_by\\\", order_by, [list]), ] ) method =\",\n \"(self.parent.is_colname_in(name)), NameError( f\\\"A vColumn has already the alias of one\",\n \"VerticaPy brings the logic to the data. # # #\",\n \"be empty\\\" ) assert not (self.parent.is_colname_in(name)), NameError( f\\\"A vColumn has\",\n \"if fun == \\\"MEDIAN\\\": fun = \\\"APPROXIMATE_MEDIAN\\\" query = \\\"SELECT\",\n \"!= 0: if return_trans: return \\\"({} - {}) / ({})\\\".format(self.alias,\",\n \"Response vColumn when method is set to 'smart'. return_enum_trans: bool,\",\n \"float = 0.05 ): \\\"\\\"\\\" --------------------------------------------------------------------------- Drops outliers in the\",\n \"---# def fillna( self, val=None, method: str = \\\"auto\\\", expr:\",\n \"self.median() new_column = \\\"COALESCE({}, {})\\\".format(\\\"{}\\\", val) elif (len(by) == 1)\",\n \": Computes the vDataFrame input aggregations. \\\"\\\"\\\" return self.aggregate([\\\"kurtosis\\\"]).values[self.alias][0] kurt\",\n \"[2018-2022] Micro Focus or one of its affiliates. # Licensed\",\n \"_verticapy_cnt_ ASC LIMIT 1\\\".format( self.alias, self.alias, self.parent.__genSQL__(), where, self.alias, n\",\n \"of nbins used for the discretization (must be > 1)\",\n \"= self.parent[y].distinct() response_cat.sort() assert response_cat == [0, 1], TypeError( \\\"vColumn\",\n \"str The field to extract. It must be one of\",\n \"do not apply it. This parameter is very useful for\",\n \"a copy vColumn to the parent vDataFrame. Parameters ---------- name:\",\n \"binary to use iv_woe.\\\".format(y) ) self.parent[y].distinct() trans = self.discretize( method=\\\"same_width\\\"\",\n \"filter the data when 'ts' is greater than November 1993\",\n \"[\\\"\\\"] result.values[\\\"pt_events\\\"] += [\\\"\\\"] result.values[\\\"woe\\\"] += [\\\"\\\"] result.values[\\\"iv\\\"] += [sum(result[\\\"iv\\\"])]\",\n \"vColumn to use to partition the TS. start_date: str /\",\n \"self.catalog self.parent.__add_to_history__( \\\"[Apply]: The vColumn '{}' was transformed with the\",\n \"approx: bool = True): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using\",\n \"ax=ax, **style_kwds, ) # ---# def rename(self, new_name: str): \\\"\\\"\\\"\",\n \"ord, non_events, events, non_events / NULLIFZERO(SUM(non_events) OVER ()) AS pt_non_events,\",\n \"vDataFrame can have multiple children vColumns whereas one vColumn can\",\n \"str): \\\"\\\"\\\" --------------------------------------------------------------------------- Computes the number of matches for the\",\n \"asin : trigonometric inverse sine atan : trigonometric inverse tangent\",\n \"simply not selecting it in the final generated SQL code.\",\n \"vDataFrame[].str_count : Computes the number of matches for the regular\",\n \"name.replace(\\\" \\\", \\\"_\\\") .replace(\\\"/\\\", \\\"_\\\") .replace(\\\",\\\", \\\"_\\\") .replace(\\\"'\\\", \\\"_\\\") )\",\n \"is 'cat_stats'\\\" ) distinct_count, is_numeric, is_date = ( self.nunique(), self.isnum(),\",\n \"= executeSQL( query=query, title=\\\"Computing the equal frequency histogram bins.\\\", method=\\\"fetchall\\\",\",\n \"k most occurent elements and their distributions as percents. Parameters\",\n \"vColumn with One-Hot Encoding. vDataFrame[].label_encode : Encodes the vColumn with\",\n \") result[idx][1] = \\\"NULL\\\" if (elem[1] == None) else str(elem[1])\",\n \"isdate(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns True if the vColumn category is\",\n \": Gaussian kernel. logistic : Logistic kernel. sigmoid : Sigmoid\",\n \"Parameters ---------- method: str, optional Method to use to compute\",\n \"method is set to 'cat_stats'. Returns ------- tablesample An object\",\n \"return self.iloc(limit=limit) # ---# def hist( self, method: str =\",\n \"type of pie chart. auto : Regular pie chart. donut\",\n \"Value (IV) Table. \\\"\\\"\\\" check_types([(\\\"y\\\", y, [str]), (\\\"nbins\\\", nbins, [int])])\",\n \"defined Encoding. vDataFrame[].discretize : Discretizes the vColumn. vDataFrame[].get_dummies : Encodes\",\n \"({3}{4} USING PARAMETERS percentile = 0.25) AS 'approx_25%', APPROXIMATE_PERCENTILE ({3}{4}\",\n \"\\\"text\\\") else: trans = (\\\"{} || ''\\\", \\\"varchar\\\", \\\"text\\\") if\",\n \"Plot. start_date: str / date, optional Input Start Date. For\",\n \"------- float sum See Also -------- vDataFrame.aggregate : Computes the\",\n \"For more information, see utilities.tablesample. See Also -------- vDataFrame[].nlargest :\",\n \"usage (unit: b). Returns ------- int vColumn expected store usage.\",\n \"0, pie_type: str = \\\"auto\\\", ax=None, **style_kwds, ): \\\"\\\"\\\" ---------------------------------------------------------------------------\",\n \"type. Parameters ---------- dtype: str New type. Returns ------- vDataFrame\",\n \"= 0.5) AS 'approx_50%', APPROXIMATE_PERCENTILE ({3}{4} USING PARAMETERS percentile =\",\n \"2.0 (the \\\"License\\\"); # You may not use this file\",\n \"except Exception as e: raise ConversionError( \\\"{}\\\\nThe vColumn {} can\",\n \"of the vColumn records. vDataFrame[].str_count : Computes the number of\",\n \") for k in range(max_floor): self.transformations += [(\\\"{}\\\", self.ctype(), self.category())]\",\n \"/\\\\ \\\\ /\\\\ \\\\/\\\\ \\\\ /\\\\ \\\"-./ \\\\ /\\\\ \\\"-.\\\\\",\n \"\\\"<\\\", \\\"[\\\", \\\"[\\\" if idx == 0 and include_lowest: op1,\",\n \"Copy]: A copy of the vColumn {} named {} was\",\n \": cardinality (count distinct) var : variance Other aggregations could\",\n \"), \\\"float\\\", \\\"float\\\", ) ] if method != \\\"robust_zscore\\\": max_floor\",\n \"the vDataFrame input aggregations. \\\"\\\"\\\" check_types( [ (\\\"method\\\", method, [\\\"auto\\\",\",\n \")[0].replace(\\\"{}\\\", self.alias) query = \\\"SELECT {} AS {}, {} AS\",\n \"parameter to False, the function's performance can drastically decrease. Returns\",\n \") # ---# def str_slice(self, start: int, step: int): \\\"\\\"\\\"\",\n \"list)): xlim_tmp = [xlim] else: xlim_tmp = [] model =\",\n \"labels: label = labels[idx] else: label = f\\\"{close_l}{first_elem};{second_elem}{close_r}\\\" conditions +=\",\n \"bool, optional Uses the threshold instead of the 'alpha' parameter.\",\n \"Label Encoding was applied to the vColumn {} using the\",\n \"object See Also -------- vDataFrame[].hist : Draws the histogram of\",\n \"is empty or invalid. max_cardinality: int, optional Maximum number of\",\n \"+ result index = [ \\\"unique\\\", \\\"count\\\", \\\"mean\\\", \\\"std\\\", \\\"min\\\",\",\n \"avg, \\\"NULLIFZERO\\\" if (nullifzero) else \\\"\\\", stddev ), \\\"float\\\", \\\"float\\\",\",\n \") result = [distinct_count, self.count()] + [item[1] for item in\",\n \": vColumn alias. catalog, dict : Catalog of pre-computed aggregations.\",\n \"/ ( 1.4826 * sauv[\\\"mad\\\"] ) elif method == \\\"zscore\\\":\",\n \"result. For more information, see utilities.tablesample. See Also -------- vDataFrame.analytic\",\n \"(\\\"ts\\\", ts, [str]), (\\\"by\\\", by, [str]), (\\\"start_date\\\", start_date, [str, datetime.datetime,\",\n \"method = method.lower() assert (method != \\\"cat_stats\\\") or (numcol), ParameterError(\",\n \"WITHIN GROUP (ORDER BY {}) OVER () FROM {} LIMIT\",\n \"self.alias, self.parent.__genSQL__() ) p_alpha, p_1_alpha = executeSQL( query=query, title=\\\"Computing the\",\n \"\\\"sinh\\\", \\\"sqrt\\\", \\\"tan\\\", \\\"tanh\\\", ], ), (\\\"x\\\", x, [int, float]),\",\n \"return self.aggregate([\\\"mad\\\"]).values[self.alias][0] # ---# def max(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the\",\n \"vDataFrame.aggregate : Computes the vDataFrame input aggregations. \\\"\\\"\\\" return self.aggregate([\\\"stddev\\\"]).values[self.alias][0]\",\n \"Computes the optimal vColumn bar width. Parameters ---------- method: str,\",\n \"------- ax Matplotlib axes object See Also -------- vDataFrame[].hist :\",\n \"if the vColumn is numerical, False otherwise. Returns ------- bool\",\n \"( parent, alias, [elem for elem in transformations], ) self.catalog\",\n \"= \\\"{}({}, {})\\\".format(func.upper(), \\\"{}\\\", x) return self.apply(func=expr) # ---# def\",\n \"Looks if some specific records are in the vDataFrame. \\\"\\\"\\\"\",\n \"self.add_copy(name=copy_name) for k in range(max_floor): self.parent[copy_name].transformations += [ (\\\"{}\\\", self.ctype(),\",\n \"composed of two flower brackets {}. For example to apply\",\n \"---# def get_dummies( self, prefix: str = \\\"\\\", prefix_sep: str\",\n \"check_types([(\\\"pat\\\", pat, [str])]) return self.apply( func=\\\"REGEXP_COUNT({}, '{}') > 0\\\".format(\\\"{}\\\", pat.replace(\\\"'\\\",\",\n \"\\\".join(by) ), ) if return_trans: return \\\"({} - {}) /\",\n \"if the vColumn is numerical. See Also -------- vDataFrame[].isbool :\",\n \"[0, n - 1] (n being the vColumn cardinality). Returns\",\n \"cmax = self.aggregate([\\\"min\\\", \\\"max\\\"]).values[self.alias] if cmax - cmin == 0:\",\n \"self.alias, self.alias, y, y, self.parent.__genSQL__(), ) query = \\\"SELECT {},\",\n \"---------- alias: str vColumn alias. transformations: list, optional List of\",\n \"(\\\"log\\\", \\\"mod\\\", \\\"pow\\\", \\\"round\\\"): expr = \\\"{}({})\\\".format(func.upper(), \\\"{}\\\") else: expr\",\n \"self.alias, cmin, \\\"NULLIFZERO\\\" if (nullifzero) else \\\"\\\", cmax, cmin, )\",\n \"cat_priority, [list]), ] ) if by: self.parent.are_namecols_in(by) by = self.parent.format_colnames(by)\",\n \"Returns ------- vDataFrame self.parent See Also -------- vDataFrame.filter: Filters the\",\n \"the method on the vColumn \\\" \\\"or simply because of\",\n \"{}\\\".format( \\\"'{}'\\\".format(str(elem[0]).replace(\\\"'\\\", \\\"''\\\")) if elem[0] != None else \\\"NULL\\\", elem[2]\",\n \"fill_outliers( self, method: str = \\\"winsorize\\\", threshold: float = 4.0,\",\n \"vDataFrame[].head : Returns the head of the vColumn. \\\"\\\"\\\" return\",\n \"frequent categories and merge the other into one unique category.\",\n \"= RandomForestClassifier(tmp_model_name) model.set_params({\\\"n_estimators\\\": 20, \\\"max_depth\\\": 8, \\\"nbins\\\": 100}) model.set_params(RFmodel_params) parameters\",\n \"== \\\"null\\\": self.apply( func=\\\"(CASE WHEN ({} BETWEEN {} AND {})\",\n \"\\\"pad\\\", \\\"bfill\\\", \\\"backfill\\\", ], ), (\\\"expr\\\", expr, [str]), (\\\"by\\\", by,\",\n \"your data. Parameters ---------- new_name: str The new vColumn alias.\",\n \"topk(self, k: int = -1, dropna: bool = True): \\\"\\\"\\\"\",\n \"Returns ------- float average See Also -------- vDataFrame.aggregate : Computes\",\n \"a specific TS field from the vColumn (only if the\",\n \"\\\"density\\\", of: str = \\\"\\\", max_cardinality: Union[int, tuple] = (6,\",\n \"\\\"NULL\\\", elem[2] if elem[2] != None else \\\"NULL\\\", ) for\",\n \"New value. Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].str_contains\",\n \"index_stop - index_start if limit <= 0: limit = 0\",\n \"'method' is set to 'smart'. A RF Regressor will be\",\n \"of vColumn based on an aggregation. \\\"\\\"\\\" check_types( [ (\\\"method\\\",\",\n \"return self.aggregate(func=[prefix + \\\"{}%\\\".format(x * 100)]).values[self.alias][ 0 ] # ---#\",\n \"mean : Average. median : median. mode : mode (most\",\n \"descriptive statistics of {}.\\\".format(self.alias), method=\\\"fetchall\\\", ) result = [distinct_count, self.count()]\",\n \"bandwidth of the kernel. kernel: str, optional The method used\",\n \"It is only valid if the vColumns are numerical. Optimized\",\n \"# # Special Methods # # ---# def __init__( self,\",\n \"query = \\\"SELECT {} AS {}, COUNT(*) AS _verticapy_cnt_, 100\",\n \"method is in ffill|pad|bfill|backfill then 'order_by' must be a list\",\n \"the vDataFrame input aggregations. \\\"\\\"\\\" return self.aggregate([\\\"kurtosis\\\"]).values[self.alias][0] kurt = kurtosis\",\n \"title=by, loc=\\\"center left\\\", bbox_to_anchor=[1, 0.5], ) ax.set_xlabel(self.alias) return ax kernel\",\n \"method == \\\"auto\\\": method = \\\"mean\\\" if (self.isnum() and self.nunique(True)\",\n \"end_date: Union[str, datetime.datetime, datetime.date] = \\\"\\\", area: bool = False,\",\n \"---------- lower: float, optional Lower bound. upper: float, optional Upper\",\n \"predictive power of an independent variable in relation to the\",\n \"func: list): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using the input\",\n \"str Name of the copy. Returns ------- vDataFrame self.parent See\",\n \"expression matches in each of the vColumn records by an\",\n \"using the mean encoding of a response. \\\"\\\"\\\" if self.category()\",\n \"be defined. numerical : Uses popular numerical aggregations during the\",\n \"< {}) UNION ALL (SELECT AVG({}) FROM vdf_table WHERE {}\",\n \"pre_comp = self.parent.__get_catalog_value__(self.alias, \\\"store_usage\\\") if pre_comp != \\\"VERTICAPY_NOT_PRECOMPUTED\\\": return pre_comp\",\n \"= True, right: bool = True, ): \\\"\\\"\\\" --------------------------------------------------------------------------- Discretizes\",\n \"is modified. Attributes ---------- alias, str : vColumn alias. catalog,\",\n \"self.parent See Also -------- vDataFrame.outliers : Computes the vDataFrame Global\",\n \"was applied to the vColumn {} using the following mapping:{}\\\".format(\",\n \"\\\"pad\\\", \\\"bfill\\\", \\\"backfill\\\"]: all_partition += [elem for elem in order_by]\",\n \"vDataFrame[].tail : Returns the a part of the vColumn. \\\"\\\"\\\"\",\n \"The function variable must be composed of two flower brackets\",\n \"n = len(result) trans = \\\"(CASE \\\" for i in\",\n \"[ (\\\"by\\\", by, [str]), (\\\"method\\\", method, [str]), (\\\"of\\\", of, [str]),\",\n \"missing elements in the vColumn with a user-specified rule. Parameters\",\n \"/ MICROSECONDS / MILLENNIUM / MILLISECONDS / MINUTE / MONTH\",\n \"max_floor = 0 for elem in by: if len(self.parent[elem].transformations) >\",\n \"result[\\\"avg\\\"][0], ) else: query = \\\"SELECT PERCENTILE_CONT({}) WITHIN GROUP (ORDER\",\n \"vColumn to use when the parameter method is set to\",\n \"3rd. end_date: str / date, optional Input End Date. For\",\n \"will represent a number. Returns ------- vDataFrame self.parent See Also\",\n \"= \\\"\\\", h: float = 0, max_cardinality: int = 8,\",\n \"AVG({}) FROM vdf_table WHERE {} < {}) UNION ALL (SELECT\",\n \"--------------------------------------------------------------------------- Draws the box plot of the vColumn. Parameters ----------\",\n \"= '{}'\\\".format(self.parent[by].alias, column) )[self.alias].density( bandwidth=bandwidth, kernel=kernel, nbins=nbins, xlim=(xmin, xmax), ax=ax,\",\n \"used for the discretization (must be > 1) Returns -------\",\n \"\\\"categorical\\\")) or ( method == \\\"is_numeric\\\" ): self.parent.__update_catalog__({\\\"index\\\": index, self.alias:\",\n \"), ) if return_trans: return \\\"({} - {}) / {}({})\\\".format(\",\n \"of the different records. For example, to check if Badr\",\n \"\\\"\\\"\\\" return self.aggregate([\\\"mad\\\"]).values[self.alias][0] # ---# def max(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates\",\n \"aggregations. \\\"\\\"\\\" return self.quantile(0.5, approx=approx) # ---# def memory_usage(self): \\\"\\\"\\\"\",\n \"See Also -------- vDataFrame.boxplot : Draws the Box Plot of\",\n \"{}) (SELECT AVG({}) FROM vdf_table WHERE {} < {}) UNION\",\n \"the box plot of the vColumn. Parameters ---------- by: str,\",\n \"beautiful graphical options. # # VerticaPy aims to do all\",\n \"'{}' END)\\\".format( bin_spatial_to_str(self.category()), \\\", \\\".join( [ \\\"'{}'\\\".format(str(elem).replace(\\\"'\\\", \\\"''\\\")) for elem\",\n \"20\\\".format( self.alias, dtype, self.alias, self.parent.__genSQL__(), self.alias ) executeSQL(query, title=\\\"Testing the\",\n \"isinstance(val, float): category, ctype = \\\"float\\\", \\\"float\\\" elif method ==\",\n \"\\\"regr_r2\\\": {}, \\\"regr_slope\\\": {}, \\\"regr_sxx\\\": {}, \\\"regr_sxy\\\": {}, \\\"regr_syy\\\": {},\",\n \"pat.replace(\\\"'\\\", \\\"''\\\")) ) # ---# def str_replace(self, to_replace: str, value:\",\n \"in self.parent._VERTICAPY_VARIABLES_[\\\"columns\\\"] ] force_columns.remove(self.alias) executeSQL( \\\"SELECT * FROM {} LIMIT\",\n \") # ---# def rename(self, new_name: str): \\\"\\\"\\\" --------------------------------------------------------------------------- Renames\",\n \"nbins, [int, float]), (\\\"h\\\", h, [int, float]), ] ) if\",\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__(\",\n \"for item in query_result] else: result = ( self.parent.describe( method=\\\"numerical\\\",\",\n \"THEN {} WHEN {} > {} THEN {} ELSE {}\",\n \"--------------------------------------------------------------------------- Computes the number of matches for the regular expression\",\n \"# / / # \\\\ / # \\\\ / #\",\n \"absolute value of the record is greater than the threshold\",\n \"or invalid. max_cardinality: int, optional Maximum number of vColumn distinct\",\n \"the vColumn. \\\"\\\"\\\" return self.iloc(limit=limit) # ---# def hist( self,\",\n \"ZEROIFNULL(LN(pt_non_events / NULLIFZERO(pt_events))) END AS iv FROM ({}) x ORDER\",\n \"approximate cardinality). See Also -------- vDataFrame.aggregate : Computes the vDataFrame\",\n \"categories. Parameters ---------- response: str Response vColumn. Returns ------- vDataFrame\",\n \"if k > 0 else \\\"\\\", self.alias ), method=\\\"fetchall\\\", )\",\n \"bandwidth: float = 1.0, kernel: str = \\\"gaussian\\\", nbins: int\",\n \"= \\\"\\\", bandwidth: float = 1.0, kernel: str = \\\"gaussian\\\",\",\n \": Computes the vDataFrame input aggregations. \\\"\\\"\\\" return self.aggregate([\\\"sum\\\"]).values[self.alias][0] #\",\n \"\\\"\\\"\\\" --------------------------------------------------------------------------- Drops outliers in the vColumn. Parameters ---------- threshold:\",\n \"and Fouad are in the vColumn. You can write the\",\n \"> 1) k: int, optional The integer k of the\",\n \"\\\"smart\\\": schema = verticapy.options[\\\"temp_schema\\\"] if not (schema): schema = \\\"public\\\"\",\n \"def spider( self, by: str = \\\"\\\", method: str =\",\n \"return bar(self, method, of, max_cardinality, nbins, h, ax=ax, **style_kwds) #\",\n \"Date. For example, time = '03-11-1993' will filter the data\",\n \"True, right: bool = True, ): \\\"\\\"\\\" --------------------------------------------------------------------------- Discretizes the\",\n \"/ sauv[ \\\"std\\\" ] elif method == \\\"minmax\\\": self.catalog[elem] =\",\n \"Also -------- vDataFrame[].ctype : Returns the vColumn database type. \\\"\\\"\\\"\",\n \"outlier. use_threshold: bool, optional Uses the threshold instead of the\",\n \"------- float aad See Also -------- vDataFrame.aggregate : Computes the\",\n \"cat: tmp_query = \\\"\\\"\\\"SELECT '{0}' AS 'index', COUNT({1}) AS count,\",\n \"= self.parent.format_colnames(by) nullifzero, n = 1, len(by) if self.isbool(): warning_message\",\n \"vColumn distinct elements to be used as categorical. The less\",\n \"{}\\\".format( trans, self.alias, self.alias, y, y, self.parent.__genSQL__(), ) query =\",\n \"must be date like (date, datetime, timestamp...) or numerical. q:\",\n \"---# def value_counts(self, k: int = 30): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns\",\n \"Also -------- vDataFrame.analytic : Adds a new vColumn to the\",\n \"\\\"\\\"\\\" check_types([(\\\"n\\\", n, [int, float])]) return self.apply(func=\\\"ROUND({}, {})\\\".format(\\\"{}\\\", n)) #\",\n \"--------------------------------------------------------------------------- Applies a default function to the vColumn. Parameters ----------\",\n \"\\\", \\\".join( [ \\\"'{}'\\\".format(str(elem).replace(\\\"'\\\", \\\"''\\\")) for elem in distinct ]\",\n \"ts: str, q: tuple = (0.25, 0.75), start_date: Union[str, datetime.datetime,\",\n \"(\\\"max_cardinality\\\", max_cardinality, [int, float]), (\\\"h\\\", h, [int, float]), (\\\"nbins\\\", nbins,\",\n \"nth_elems += [str(total)] total += nb where = \\\"WHERE _verticapy_row_nb_\",\n \"vDataFrame.\\\".format(self.alias) ) return parent # ---# def drop_outliers( self, threshold:\",\n \"- len( self.transformations ) for k in range(max_floor): self.transformations +=\",\n \"the input vColumn. \\\"\\\"\\\" check_types([(\\\"n\\\", n, [int, float])]) return self.apply(func=\\\"ROUND({},\",\n \"Parameters ---------- func: list List of the different aggregation. aad\",\n \"2 bars. It is only valid if the vColumns are\",\n \"vColumn {} using the following mapping:{}\\\".format( self.alias, text_info ) )\",\n \"---# def nlargest(self, n: int = 10): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns\",\n \"prod : product range : difference between the max and\",\n \"Computes the vDataFrame input aggregations. \\\"\\\"\\\" return self.aggregate([\\\"min\\\"]).values[self.alias][0] # ---#\",\n \"to use to discretize the vColumn. auto : Uses method\",\n \"elif \\\"column\\\" in kwargs: column = kwargs[\\\"column\\\"] else: check =\",\n \"the method to 'numerical' if the vColumn is numerical ,\",\n \"str(elem[1]) new_column = \\\"COALESCE({}, DECODE({}, {}, NULL))\\\".format( \\\"{}\\\", by[0], \\\",\",\n \"/ MONTH / QUARTER / SECOND / TIME ZONE /\",\n \"(dropna) and (pre_comp != None): return pre_comp assert n >=\",\n \"idx)[\\\"color\\\"], lw=4, ), ] ax.set_title(\\\"KernelDensity\\\") ax.legend( custom_lines, columns, title=by, loc=\\\"center\",\n \"vColumn 'of'. min : Minimum of the vColumn 'of'. max\",\n \"[\\\"winsorize\\\", \\\"null\\\", \\\"mean\\\"]), (\\\"alpha\\\", alpha, [int, float]), (\\\"use_threshold\\\", use_threshold, [bool]),\",\n \"= f\\\"{close_l}{first_elem};{second_elem}{close_r}\\\" conditions += [ f\\\"'{first_elem}' {op1} {column} AND {column}\",\n \"= None elif method == \\\"robust_zscore\\\": self.catalog[elem] = (sauv[elem] -\",\n \"density : Percentage of the distribution. mean : Average of\",\n \"WHERE {} IS NOT NULL \\\".format(self.alias) if (dropna) else \\\"\",\n \"vColumn {} can not be converted to {}\\\".format( e, self.alias,\",\n \"values = { \\\"index\\\": [\\\"name\\\", \\\"dtype\\\"] + index, \\\"value\\\": [self.alias,\",\n \"if the vColumns are numerical. Optimized h will be computed\",\n \"to order the data\\\" ) desc = \\\"\\\" if (method\",\n \"by: if len(self.parent[elem].transformations) > max_floor: max_floor = len(self.parent[elem].transformations) max_floor -=\",\n \"( \\\"label_encode is only available for categorical variables.\\\" ) warnings.warn(warning_message,\",\n \"str = \\\"auto\\\"): \\\"\\\"\\\" --------------------------------------------------------------------------- Computes the optimal vColumn bar\",\n \"some conditions. vDataFrame[].discretize : Discretizes the vColumn. vDataFrame[].label_encode : Encodes\",\n \"\\\"regr_sxy\\\": {}, \\\"regr_syy\\\": {}, } for elem in catalog: self.catalog[elem]\",\n \"Propagation of the next element (Constant Interpolation). ffill : Propagation\",\n \"if Badr and Fouad are in the vColumn. You can\",\n \"---# def normalize( self, method: str = \\\"zscore\\\", by: list\",\n \"else: final_transformation = [ ( \\\"({} - {}) / {}({}\",\n \"---# def div(self, x: float): \\\"\\\"\\\" --------------------------------------------------------------------------- Divides the vColumn\",\n \"empty or invalid. max_cardinality: int/tuple, optional Maximum number of distinct\",\n \"the vColumn. auto : Uses method 'same_width' for numerical vColumns,\",\n \"data. # # # Modules # # Standard Python Modules\",\n \"transformed. Parameters ---------- to_replace: str Regular expression to replace. value:\",\n \"to 2.\\\" ) assert len(breaks) == len(labels) + 1 or\",\n \"self.parent.describe( method=\\\"numerical\\\", columns=[self.alias], unique=False ) .transpose() .values[self.alias] ) count, vColumn_min,\",\n \"assert self.parent[y].nunique() == 2, TypeError( \\\"vColumn {} must be binary\",\n \"\\\" LIMIT {}\\\".format(limit) else: limit = \\\"\\\" query = \\\"(SELECT\",\n \"be the result of using previously the method on the\",\n \"p_alpha, p_1_alpha = ( -threshold * result[\\\"std\\\"][0] + result[\\\"avg\\\"][0], threshold\",\n \"bar width. \\\"\\\"\\\" check_types( [(\\\"method\\\", method, [\\\"sturges\\\", \\\"freedman_diaconis\\\", \\\"fd\\\", \\\"auto\\\"])]\",\n \"method = method.lower() if method == \\\"auto\\\": pre_comp = self.parent.__get_catalog_value__(self.alias,\",\n \"'{}')\\\".format(\\\"{}\\\", val) elif expr: new_column = \\\"COALESCE({}, {})\\\".format(\\\"{}\\\", expr) elif\",\n \"the vColumn outliers. mean : Replaces the upper and lower\",\n \"elements. See Also -------- vDataFrame.aggregate : Computes the vDataFrame input\",\n \"offset: int = 0): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns a part of\",\n \"x != 0, ValueError(\\\"Division by 0 is forbidden !\\\") return\",\n \"self.parent.__update_catalog__({\\\"index\\\": [\\\"numh\\\"], self.alias: [best_h]}) if self.category() == \\\"int\\\": best_h =\",\n \"The vColumn will be transformed. Parameters ---------- to_replace: str Regular\",\n \"dtype ) ) # ---# def avg(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates\",\n \"{}\\\".format( bin_spatial_to_str(self.category(), self.alias), self.parent.__genSQL__(), ), title=\\\"Computing the Store Usage of\",\n \"most occurent element density unique : cardinality (count distinct) var\",\n \"in the vColumn. vDataFrame.outliers : Adds a new vColumn labeled\",\n \"0, ValueError(\\\"Division by 0 is forbidden !\\\") return self.apply(func=\\\"{} /\",\n \"[bool])]) try: parent = self.parent force_columns = [ column for\",\n \"conditions, column = [], self.alias for idx in range(len(breaks) -\",\n \"Minimum of the vColumn 'of'. max : Maximum of the\",\n \"the a part of the vColumn. \\\"\\\"\\\" return self.iloc(limit=limit) #\",\n \"(ORDER BY {}) OVER (), PERCENTILE_CONT(1 - {}) WITHIN GROUP\",\n \"expression is in each of the vColumn records. vDataFrame[].str_count :\",\n \"idx, column in enumerate(columns): param = {\\\"color\\\": colors[idx % len(colors)]}\",\n \".values[self.alias] ) count, vColumn_min, vColumn_025, vColumn_075, vColumn_max = ( result[0],\",\n \"val == None: warning_message = \\\"The vColumn {} has no\",\n \"executeSQL( query, title=\\\"Different aggregations to compute the optimal h.\\\", method=\\\"fetchrow\\\",\",\n \"[int(item[1]) for item in result], \\\"percent\\\": [float(round(item[2], 3)) for item\",\n \"kwargs[\\\"color\\\"] = gen_colors()[0] if not (\\\"legend\\\" in kwargs): kwargs[\\\"legend\\\"] =\",\n \"[\\\"unique\\\", \\\"count\\\"] + [item[0] for item in query_result] else: result\",\n \"MIN({}), MAX({}) FROM {} GROUP BY {}\\\".format( by[0], self.alias, self.alias,\",\n \"= True if pie_type == \\\"rose\\\" else False if of:\",\n \"vDataFrame[].nsmallest : Returns the n smallest elements in the vColumn.\",\n \"\\\"\\\"\\\" check_types([(\\\"pat\\\", pat, [str])]) return self.apply( func=\\\"REGEXP_COUNT({}, '{}') > 0\\\".format(\\\"{}\\\",\",\n \"[int, float]), (\\\"h\\\", h, [int, float]), ] ) if of:\",\n \"to consider when drawing the box plot. The other categories\",\n \"it's better practice to use this method when first preparing\",\n \"spider( self, by: str = \\\"\\\", method: str = \\\"density\\\",\",\n \"the parameter 'numcol' must be defined. numerical : Uses popular\",\n \"def geo_plot(self, *args, **kwargs): \\\"\\\"\\\" --------------------------------------------------------------------------- Draws the Geospatial object.\",\n \"one of \\\" \\\"the parameters ('prefix', 'prefix_sep'), you'll be able\",\n \"\\\" \\\" result = executeSQL( \\\"SELECT {} FROM (SELECT {},\",\n \"is numerical. \\\"\\\"\\\" return self.ctype().lower() in (\\\"bool\\\", \\\"boolean\\\") # ---#\",\n \"kwargs): from verticapy.plot import gen_colors kwargs[\\\"color\\\"] = gen_colors()[0] if not\",\n \"will be included. right: bool, optional How the intervals should\",\n \"[\\\"store_usage\\\"], self.alias: [store_usage]} ) return store_usage # ---# def str_contains(self,\",\n \"int(nbins))) * int(nbins): nth_elems += [str(total)] total += nb where\",\n \"element percent : percent of non-missing elements q% : q\",\n \"check_types( [ (\\\"method\\\", method, [\\\"zscore\\\", \\\"robust_zscore\\\", \\\"minmax\\\"]), (\\\"by\\\", by, [list]),\",\n \"-1, k: int = 6, new_category: str = \\\"Others\\\", RFmodel_params:\",\n \"Also -------- vDataFrame[].apply : Applies a function to the vColumn.\",\n \"|| FLOOR({} / {}) * {} || ';' || (FLOOR({}\",\n \"the comma. Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].apply\",\n \"all_partition += [elem for elem in order_by] for elem in\",\n \"# |______ / / / # |____/ / / #\",\n \"(lower != None) or (upper != None), ParameterError( \\\"At least\",\n \"phases. xlim: tuple, optional Set the x limits of the\",\n \"< 0: index_stop += self.parent.shape()[0] limit = index_stop - index_start\",\n \"'{}')\\\".format(\\\"{}\\\", pat.replace(\\\"'\\\", \\\"''\\\")) ) # ---# def str_extract(self, pat: str):\",\n \"\\\"\\\" ): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using multiple statistical\",\n \"prefix_sep: str, optional Prefix delimitor of the dummies. drop_first: bool,\",\n \"<= 0: if nbins <= 0: h = self.numh() else:\",\n \"sum : sum std : standard deviation topk : kth\",\n \"used instead of the parent vDataFrame. This parameter is used\",\n \"Returns ------- float skewness See Also -------- vDataFrame.aggregate : Computes\",\n \"'{}'\\\".format( e, func.replace(\\\"{}\\\", \\\"x\\\"), self.alias.replace('\\\"', \\\"\\\") ) ) # ---#\",\n \"self.catalog: sauv[elem] = self.catalog[elem] self.parent.__update_catalog__(erase=True, columns=[self.alias]) try: if \\\"count\\\" in\",\n \"vDataFrame.case_when : Creates a new feature by evaluating some conditions.\",\n \"schema = verticapy.options[\\\"temp_schema\\\"] if not (schema): schema = \\\"public\\\" name\",\n \"0: index += self.parent.shape()[0] query = \\\"SELECT {}{} FROM {}{}\",\n \"non-missing elements q% : q quantile (ex: 50% for the\",\n \"[xlim] else: xlim_tmp = [] model = KernelDensity( name, bandwidth=bandwidth,\",\n \"vColumn {} was discretized.\\\".format(self.alias) ) return self.parent # ---# def\",\n \"{}{}GROUP BY {} ORDER BY _verticapy_cnt_ DESC LIMIT {}) VERTICAPY_SUBTABLE\",\n \"\\\\ # \\\\ \\\\ \\\\'/ \\\\ \\\\ \\\\____ \\\\ \\\\\",\n \"== \\\"float\\\": model = RandomForestRegressor(tmp_model_name) else: model = RandomForestClassifier(tmp_model_name) model.set_params({\\\"n_estimators\\\":\",\n \") for elem in result if elem[2] != None ]\",\n \"h, max_cardinality, cat_priority, ax=ax, **style_kwds) # ---# def category(self): \\\"\\\"\\\"\",\n \"than the lower bound to the lower bound itself and\",\n \"global outlier). \\\"\\\"\\\" check_types( [ (\\\"alpha\\\", alpha, [int, float]), (\\\"use_threshold\\\",\",\n \"will be updated when the parent vDataFrame is modified. Attributes\",\n \"alpha, self.alias, self.parent.__genSQL__() ) p_alpha, p_1_alpha = executeSQL( query=query, title=\\\"Computing\",\n \"+= [ ( \\\"{}::{}\\\".format(\\\"{}\\\", dtype), dtype, get_category_from_vertica_type(ctype=dtype), ) ] self.parent.__add_to_history__(\",\n \"'lower' or 'upper' must have a numerical value\\\" ) lower_when\",\n \"columns naming.\\\\nBy changing one of \\\" \\\"the parameters ('prefix', 'prefix_sep'),\",\n \"the input element from the vColumn. Parameters ---------- x: float\",\n \"-------- vDataFrame.aggregate : Computes the vDataFrame input aggregations. \\\"\\\"\\\" return\",\n \"ORDER BY split_value::float\\\".format( \\\" UNION ALL \\\".join(query), nbins - 1\",\n \"by transforming the values lesser than the lower bound to\",\n \"check_types([(\\\"dropna\\\", dropna, [bool]), (\\\"n\\\", n, [int, float])]) if n ==\",\n \"\\\"\\\"): \\\"\\\"\\\" --------------------------------------------------------------------------- Applies a function to the vColumn. Parameters\",\n \"result.values[\\\"pt_non_events\\\"] += [\\\"\\\"] result.values[\\\"pt_events\\\"] += [\\\"\\\"] result.values[\\\"woe\\\"] += [\\\"\\\"] result.values[\\\"iv\\\"]\",\n \"'hour'... start: bool, optional If set to True, the record\",\n \") lower_when = ( \\\"WHEN {} < {} THEN {}\",\n \"Micro Focus or one of its affiliates. # Licensed under\",\n \"optional Parent of the vColumn. One vDataFrame can have multiple\",\n \"{self.alias: val} return self.parent.isin(val) # ---# def isnum(self): \\\"\\\"\\\" ---------------------------------------------------------------------------\",\n \"method will return the transformation used instead of the parent\",\n \"\\\"approx_median\\\"]).values[self.alias] mad *= 1.4826 if mad != 0: if return_trans:\",\n \"Plot. step: bool, optional If set to True, draw a\",\n \"NULL LIMIT 20\\\".format( self.alias, dtype, self.alias, self.parent.__genSQL__(), self.alias ) executeSQL(query,\",\n \"== \\\"minmax\\\": self.catalog[\\\"min\\\"] = 0 self.catalog[\\\"max\\\"] = 1 self.parent.__add_to_history__( \\\"[Normalize]:\",\n \"\\\"\\\"\\\" --------------------------------------------------------------------------- Discretizes the vColumn using the input list. Parameters\",\n \"method.lower() == \\\"sturges\\\": best_h = sturges elif method.lower() in (\\\"freedman_diaconis\\\",\",\n \"For example: 0.25 represents Q1. approx: bool, optional If set\",\n \"Warning) else: distinct_elements = self.distinct() expr = [\\\"DECODE({}\\\"] text_info =\",\n \"the vColumn using multiple statistical aggregations: min, max, median, unique...\",\n \"\\\"SELECT * FROM {} LIMIT 10\\\".format( self.parent.__genSQL__(force_columns=force_columns) ), print_time_sql=False, )\",\n \"(val == None): val = self.mode(dropna=True) if val == None:\",\n \"{0} ORDER BY COUNT(*) DESC LIMIT {1})\\\"\\\"\\\".format( self.alias, max_cardinality )\",\n \"method == \\\"auto\\\": pre_comp = self.parent.__get_catalog_value__(self.alias, \\\"numh\\\") if pre_comp !=\",\n \"else \\\"'{}'\\\".format(str(elem[0]).replace(\\\"'\\\", \\\"''\\\")) ) result[idx][1] = \\\"NULL\\\" if (elem[1] ==\",\n \"as categorical. The less frequent elements will be gathered together\",\n \"optional Drops the first dummy to avoid the creation of\",\n \"func.replace(\\\"{}\\\", self.alias), self.parent.__genSQL__(), self.alias, ), \\\"apply_test_feature\\\", ) except: ctype =\",\n \"\\\"same_freq\\\", \\\"topk\\\"], ), (\\\"return_enum_trans\\\", return_enum_trans, [bool]), ] ) method =\",\n \"containing the result. For more information, see utilities.tablesample. See Also\",\n \": Returns the tail of the vColumn. \\\"\\\"\\\" check_types([(\\\"limit\\\", limit,\",\n \"upper: float, optional Upper bound. Returns ------- vDataFrame self.parent See\",\n \"# ---# def range_plot( self, ts: str, q: tuple =\",\n \"to the vColumn. Parameters ---------- func: str, Function in pure\",\n \"Returns ------- float optimal bar width. \\\"\\\"\\\" check_types( [(\\\"method\\\", method,\",\n \"sys.getsizeof(self.alias) + sys.getsizeof(self.transformations) + sys.getsizeof(self.catalog) ) for elem in self.catalog:\",\n \"of the vColumn distinct elements to be used as categorical\",\n \"of non-Missing elements). Returns ------- int number of non-Missing elements.\",\n \"\\\"{}\\\") else: expr = \\\"{}({}, {})\\\".format(func.upper(), \\\"{}\\\", x) return self.apply(func=expr)\",\n \"(self.category() == \\\"int\\\") else \\\"\\\" if (h > 1) or\",\n \"a customized expression. \\\"\\\"\\\" if isinstance(func, str_sql): func = str(func)\",\n \"NOT NULL GROUP BY {} ORDER BY {}\\\".format( bin_spatial_to_str(self.category(), self.alias),\",\n \"vDataFrame.bar : Draws the Bar Chart of the input vColumns\",\n \"def astype(self, dtype: str): \\\"\\\"\\\" --------------------------------------------------------------------------- Converts the vColumn to\",\n \"ParameterError(\\\"Parameter 'n' must be greater or equal to 1\\\") where\",\n \"max_cardinality, [int, float]), (\\\"h\\\", h, [int, float]), (\\\"pie_type\\\", pie_type, [\\\"auto\\\",\",\n \"BY {}) AS _verticapy_row_nb_ FROM {} WHERE {} IS NOT\",\n \"vDataFrame.eval : Evaluates a customized expression. \\\"\\\"\\\" if isinstance(func, str_sql):\",\n \"of mean). Returns ------- float sem See Also -------- vDataFrame.aggregate\",\n \"\\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using the input functions. Parameters\",\n \"table = \\\"(SELECT DATEDIFF('second', '{}'::timestamp, {}) AS {} FROM {})\",\n \"---# def tail(self, limit: int = 5): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns\",\n \"\\\"\\\"\\\" check_types([(\\\"y\\\", y, [str]), (\\\"nbins\\\", nbins, [int])]) self.parent.are_namecols_in(y) y =\",\n \"+ 2)), 1e-99, ) fd = max(2.0 * (vColumn_075 -\",\n \"------- vDataFrame self.parent See Also -------- vDataFrame[].fill_outliers : Fills the\",\n \"or computed) nbins: int, optional Number of nbins. If empty,\",\n \"---# class vColumn(str_sql): \\\"\\\"\\\" --------------------------------------------------------------------------- Python object which that stores\",\n \"user defined Encoding. vDataFrame[].discretize : Discretizes the vColumn. vDataFrame[].get_dummies :\",\n \"file except in compliance with the License. # You may\",\n \"list List of the different aggregation. aad : average absolute\",\n \"or computed) h: float, optional Interval width of the bar.\",\n \"bool True if the vColumn category is date. See Also\",\n \"to use to partition the TS. start_date: str / date,\",\n \"breaks[idx + 1] if right: op1, op2, close_l, close_r =\",\n \"0): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns a part of the vColumn (delimited\",\n \"optional Integer corresponding to the offset. For example, if n\",\n \"if (method == \\\"mode\\\") and (val == None): val =\",\n \"def std(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using 'std' (Standard\",\n \"{} OFFSET {}\\\".format( bin_spatial_to_str(self.category(), self.alias), self.alias, self.parent.__genSQL__(), self.parent.__get_last_order_by__(), limit, offset,\",\n \") return self.parent except Exception as e: raise ConversionError( \\\"{}\\\\nThe\",\n \"[str, datetime.datetime, datetime.date, int, float], ), (\\\"plot_median\\\", plot_median, [bool]), ]\",\n \"catalog, dict : Catalog of pre-computed aggregations. parent, vDataFrame :\",\n \"if (use_numbers_as_suffix) else '\\\"{}{}\\\"'.format( prefix, str(distinct_elements[k]).replace('\\\"', \\\"_\\\") ) ) name\",\n \"query, ) query = \\\"SELECT {}, ord, non_events, events, non_events\",\n \"for i in range(1, n): trans += \\\"WHEN {} BETWEEN\",\n \"Encoding was applied to the vColumn {} using the following\",\n \"vColumn using the average of the response partitioned by the\",\n \"FROM {} WHERE {} IS NOT NULL ORDER BY {}\",\n \"else: columns = [self.alias] if of: self.parent.are_namecols_in(of) of = self.parent.format_colnames(of)\",\n \"up to the next whole number cos : trigonometric cosine\",\n \"if (self.isnum() and self.nunique(True) > 6) else \\\"mode\\\" total =\",\n \"2 in case of discretization using the method 'smart'.\\\" )\",\n \"Encodes the vColumn with a user defined Encoding. vDataFrame[].discretize :\",\n \"query, title=\\\"Different aggregations to compute the optimal h.\\\", method=\\\"fetchrow\\\", )\",\n \"start_date: str / date, optional Input Start Date. For example,\",\n \"\\\\/_/ \\\\/_____/ \\\\/_____/ \\\\/_____/ \\\\/_____/ \\\\/_/ \\\\/_/ \\\\/_/ \\\\/_/ #\",\n \"), ( \\\"end_date\\\", end_date, [str, datetime.datetime, datetime.date, int, float], ),\",\n \"{}) OVER (), PERCENTILE_CONT(1 - {}) WITHIN GROUP (ORDER BY\",\n \"to 'smart'. A RF Regressor will be trained if the\",\n \"\\\"SELECT {}, {} FROM {} LIMIT 1\\\".format( cmax, cmin, self.parent.__genSQL__()\",\n \"Discretizes the vColumn using the input method. Parameters ---------- method:\",\n \"not (self.parent.is_colname_in(new_name)), NameError( f\\\"A vColumn has already the alias {new_name}.\\\\nBy\",\n \"0.1) AS 'approx_10%', APPROXIMATE_PERCENTILE ({3}{4} USING PARAMETERS percentile = 0.25)\",\n \"Discretizes the vColumn using the input list. Parameters ---------- breaks:\",\n \"return self elif (n == 1) and (self.parent[by[0]].nunique() < 50):\",\n \"vColumn. \\\"\\\"\\\" check_types([(\\\"pat\\\", pat, [str])]) return self.apply( func=\\\"REGEXP_COUNT({}, '{}')\\\".format(\\\"{}\\\", pat.replace(\\\"'\\\",\",\n \"query ) query_result = executeSQL( query=query, title=\\\"Computing the descriptive statistics\",\n \"---# def iloc(self, limit: int = 5, offset: int =\",\n \"), ) if return_trans: return \\\"({} - {}) / {}({}\",\n \"width of the bar. If empty, an optimized h will\",\n \"the Matplotlib functions. Returns ------- ax Matplotlib axes object See\",\n \"KernelDensity( name, bandwidth=bandwidth, kernel=kernel, nbins=nbins, xlim=xlim_tmp, store=False, ) try: result\",\n \"self.parent._VERTICAPY_VARIABLES_[\\\"exclude_columns\\\"] += [self.alias] if add_history: self.parent.__add_to_history__( \\\"[Drop]: vColumn {} was\",\n \"ax=ax, **updated_dict(param, style_kwds, idx), ) custom_lines += [ Line2D( [0],\",\n \"chart of the vColumn based on an aggregation. \\\"\\\"\\\" if\",\n \"elif method == \\\"mean\\\": query = \\\"WITH vdf_table AS (SELECT\",\n \"\\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using 'aad' (Average Absolute Deviation).\",\n \"self.isbool(): all_new_features = [] prefix = ( self.alias.replace('\\\"', \\\"\\\") +\",\n \"= 1 elif method == \\\"minmax\\\": self.catalog[\\\"min\\\"] = 0 self.catalog[\\\"max\\\"]\",\n \"to an aggregation. vColumns will memorize the already computed aggregations\",\n \"---------- x: float Input number. Returns ------- vDataFrame self.parent See\",\n \"dtype = ctype # ---# def date_part(self, field: str): \\\"\\\"\\\"\",\n \"float]), ] ) if func not in (\\\"log\\\", \\\"mod\\\", \\\"pow\\\",\",\n \"{} was added to the vDataFrame.\\\".format( self.alias, name ) )\",\n \"total self.catalog[\\\"percent\\\"] = ( 100 * (int(sauv[\\\"count\\\"]) + total) /\",\n \"{} AS index, non_events, events, pt_non_events, pt_events, CASE WHEN non_events\",\n \"int, optional Integer corresponding to the offset. For example, if\",\n \"self.parent See Also -------- vDataFrame.drop: Drops the input vColumns from\",\n \"else \\\" was \\\" self.parent.__add_to_history__( \\\"[Get Dummies]: One hot encoder\",\n \"WHERE {} IS NULL\\\".format(self.alias) if (category in (\\\"None\\\", None)) else\",\n \"ORDER BY {}))\\\".format( \\\"{}\\\", \\\"{}\\\", partition_by, order_by_ts ) if method\",\n \"will be closed on the right. Returns ------- vDataFrame self.parent\",\n \"-------- vDataFrame.aggregate : Computes the vDataFrame input aggregations. \\\"\\\"\\\" check_types([(\\\"dropna\\\",\",\n \"if index_start < 0: index_start += self.parent.shape()[0] if isinstance(index_stop, int):\",\n \"of {}.\\\".format(self.alias), method=\\\"fetchall\\\", ) result = [distinct_count, self.count()] + [item[1]\",\n \"max_cardinality, nbins, h, ax=ax, **style_kwds) # ---# def iloc(self, limit:\",\n \"prod = product # ---# def quantile(self, x: float, approx:\",\n \"of = self.parent.format_colnames(of) from verticapy.plot import bar return bar(self, method,\",\n \"utilities.tablesample. See Also -------- vDataFrame[].describe : Computes the vColumn descriptive\",\n \"# ---# def cut( self, breaks: list, labels: list =\",\n \"using multiple statistical aggregations: min, max, median, unique... depending on\",\n \"\\\"''\\\") ) transformations = self.transformations + [(expr, \\\"bool\\\", \\\"int\\\")] new_vColumn\",\n \"in range(max_floor): self.transformations += [(\\\"{}\\\", self.ctype(), self.category())] self.transformations += final_transformation\",\n \"{} AS apply_test_feature FROM {} WHERE {} IS NOT NULL\",\n \"float, optional Interval width if the vColumn is numerical or\",\n \"\\\"robust_zscore\\\": self.catalog[elem] = (sauv[elem] - sauv[\\\"approx_50%\\\"]) / ( 1.4826 *\",\n \"vColumn type is date like). The vColumn will be transformed.\",\n \"method 'smart'.\\\" ) assert response, ParameterError( \\\"Parameter 'response' can not\",\n \"self.parent # ---# def dropna(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Filters the vDataFrame\",\n \"len(breaks) >= 2, ParameterError( \\\"Length of parameter 'breaks' must be\",\n \"vDataFrame.aggregate : Computes the vDataFrame input aggregations. \\\"\\\"\\\" return self.aggregate([\\\"skewness\\\"]).values[self.alias][0]\",\n \"MAX({}) FROM {} GROUP BY {}\\\".format( by[0], self.alias, self.alias, self.parent.__genSQL__(),\",\n \"instead of the ceiling. Returns ------- vDataFrame self.parent See Also\",\n \"sturges = max( float(vColumn_max - vColumn_min) / int(math.floor(math.log(count, 2) +\",\n \"fun = \\\"APPROXIMATE_MEDIAN\\\" query = \\\"SELECT {}, {}({}) FROM {}\",\n \"See Also -------- vDataFrame[].date_part : Extracts a specific TS field\",\n \"dropna: bool = False, n: int = 1): \\\"\\\"\\\" ---------------------------------------------------------------------------\",\n \"from typing import Union # VerticaPy Modules import verticapy from\",\n \"RF Classifier otherwise. Example: Write {\\\"n_estimators\\\": 20, \\\"max_depth\\\": 10} to\",\n \"1 else \\\" was \\\" self.parent.__add_to_history__( \\\"[Get Dummies]: One hot\",\n \"self.alias: [best_h]}) if self.category() == \\\"int\\\": best_h = max(math.floor(best_h), 1)\",\n \"{}, \\\"regr_r2\\\": {}, \\\"regr_slope\\\": {}, \\\"regr_sxx\\\": {}, \\\"regr_sxy\\\": {}, \\\"regr_syy\\\":\",\n \"None): return pre_comp assert n >= 1, ParameterError(\\\"Parameter 'n' must\",\n \"new_column = \\\"COALESCE({}, '{}')\\\".format(\\\"{}\\\", val) elif expr: new_column = \\\"COALESCE({},\",\n \"categories {} to normalize.\\\".format( by[0] ), method=\\\"fetchall\\\", ) cmin =\",\n \"of a response. \\\"\\\"\\\" check_types( [ (\\\"RFmodel_params\\\", RFmodel_params, [dict]), (\\\"return_enum_trans\\\",\",\n \"None), ValueError( \\\"vColumn doesn't allow slicing having steps different than\",\n \"self, ts, q, start_date, end_date, plot_median, ax=ax, **style_kwds, ) #\",\n \"drastically decrease. Returns ------- float/str median See Also -------- vDataFrame.aggregate\",\n \"be considered during the computation. Returns ------- tablesample An object\",\n \"\\\\ \\\\ \\\\_\\\\ \\\\ \\\\ \\\\ \\\\-./\\\\ \\\\ \\\\ \\\\\",\n \"threshold * result[\\\"std\\\"][0] + result[\\\"avg\\\"][0], ) else: query = \\\"SELECT\",\n \") title = \\\"Reads {} {} largest elements.\\\".format(self.alias, n) return\",\n \"unique=False ) .transpose() .values[self.alias] ) result = [distinct_count] + result\",\n \") n = 1 if drop_first else 0 for k\",\n \"the vColumn {}\\\\n{} feature{}created: {}\\\".format( self.alias, len(all_new_features), conj, \\\", \\\".join(all_new_features)\",\n \") + \\\".\\\" ) return self.parent one_hot_encode = get_dummies #\",\n \"/ HOUR / ISODOW / ISOWEEK / ISOYEAR / MICROSECONDS\",\n \"int, optional Maximum number of the vColumn distinct elements to\",\n \"\\\"''\\\")) ) # ---# def str_count(self, pat: str): \\\"\\\"\\\" ---------------------------------------------------------------------------\",\n \"numerical. \\\"\\\"\\\" return self.category() == \\\"date\\\" # ---# def isin(self,\",\n \"[(expr, \\\"bool\\\", \\\"int\\\")] new_vColumn = vColumn( name, parent=self.parent, transformations=transformations, catalog={\",\n \"\\\"\\\"\\\" --------------------------------------------------------------------------- Draws the bar chart of the vColumn based\",\n \"vDataFrame[].get_dummies : Encodes the vColumn with One-Hot Encoding. vDataFrame[].label_encode :\",\n \"function to the input vColumn. Returns ------- vDataFrame self.parent See\",\n \"pie return pie( self, method, of, max_cardinality, h, donut, rose,\",\n \"of the merging category when using the 'topk' method. RFmodel_params:\",\n \"+= nb where = \\\"WHERE _verticapy_row_nb_ IN ({})\\\".format( \\\", \\\".join([\\\"1\\\"]\",\n \"{}\\\".format( self.parent.__genSQL__(), self.alias, self.alias, n ) title = \\\"Reads {}\",\n \"int, optional Number of bins used for the discretization (must\",\n \"\\\"int\\\", \\\"float\\\") ] self.parent.__update_catalog__(erase=True, columns=[self.alias]) self.parent.__add_to_history__( \\\"[Mean Encode]: The vColumn\",\n \"{}) VERTICAPY_OPTIMAL_H_TABLE\\\".format( min_date, self.alias, self.alias, self.parent.__genSQL__() ) query = \\\"SELECT\",\n \"if isinstance(top, decimal.Decimal): top = float(top) self.parent.__update_catalog__( {\\\"index\\\": [\\\"top{}\\\".format(n)], self.alias:\",\n \"WHERE {} IS NOT NULL ORDER BY {} ASC LIMIT\",\n \"/ {}({})\\\".format( \\\"{}\\\", avg, \\\"NULLIFZERO\\\" if (nullifzero) else \\\"\\\", stddev\",\n \"h = round(h, 2) elif h > 0.0001: h =\",\n \"total, query, nth_elems = nb, [], [] while total <\",\n \"/ ({})\\\".format(self.alias, med, mad) else: final_transformation = [ ( \\\"({}\",\n \"index, \\\"value\\\": [self.alias, self.ctype()] + result, } if ((is_date) and\",\n \"Table. It tells the predictive power of an independent variable\",\n \"50% to get the median). It can also be a\",\n \"else: trans = (\\\"{} || ''\\\", \\\"varchar\\\", \\\"text\\\") if (self.isnum()\",\n \"# ---# def div(self, x: float): \\\"\\\"\\\" --------------------------------------------------------------------------- Divides the\",\n \"(numcol), ParameterError( \\\"The parameter 'numcol' must be a vDataFrame column\",\n \"aggregations. \\\"\\\"\\\" return self.aggregate([\\\"sem\\\"]).values[self.alias][0] # ---# def skewness(self): \\\"\\\"\\\" ---------------------------------------------------------------------------\",\n \"-1, dropna: bool = True): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns the k\",\n \"the quantiles of {}.\\\".format(self.alias), method=\\\"fetchrow\\\", ) if method == \\\"winsorize\\\":\",\n \"power of another number round : rounds a value to\",\n \"a function to the input vColumn. \\\"\\\"\\\" check_types([(\\\"x\\\", x, [int,\",\n \"also increase the time of the learning and scoring phases.\",\n \"Draws the box plot of the vColumn. Parameters ---------- by:\",\n \"n ), title=\\\"Computing the mode.\\\", method=\\\"fetchall\\\", ) top = None\",\n \"for the discretization (must be > 1) Returns ------- tablesample\",\n \"return best_h # ---# def nunique(self, approx: bool = True):\",\n \"and Sturges. freedman_diaconis : Freedman Diaconis [2 * IQR /\",\n \"0 all_partition = by if method in [\\\"ffill\\\", \\\"pad\\\", \\\"bfill\\\",\",\n \"method=\\\"fetchall\\\", ) top = None if not (result) else result[0][0]\",\n \"= [by] if isinstance(order_by, str): order_by = [order_by] check_types( [\",\n \"*args / **kwargs Any optional parameter to pass to the\",\n \"the DB version you are using. Returns ------- tablesample An\",\n \"based on an aggregation. Parameters ---------- by: str, optional vColumn\",\n \"text / binary / spatial / uuid / undefined Returns\",\n \"Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].dropna : Drops\",\n \"str, optional New value. Returns ------- vDataFrame self.parent See Also\",\n \"+ 2\\\". copy_name: str, optional If not empty, a copy\",\n \"( \\\"UNION ALL (SELECT 'Others', SUM(count) FROM (SELECT COUNT(*) AS\",\n \"/ int(nbins))) * int(nbins): nth_elems += [str(total)] total += nb\",\n \"when the vColumn is null, 1 otherwise. expr: str, optional\",\n \"The vColumn {} was transformed using a mean encoding with\",\n \"max_floor = 0 all_partition = by if method in [\\\"ffill\\\",\",\n \"-------- vDataFrame[].nsmallest : Returns the n smallest elements in the\",\n \"(\\\"{} || ''\\\", \\\"varchar\\\", \\\"text\\\") if (self.isnum() and method ==\",\n \"enumerate(result): result[idx][0] = ( \\\"NULL\\\" if (elem[0] == None) else\",\n \"by dropping the current vColumn and creating a copy with\",\n \"the vColumn. \\\"\\\"\\\" check_types([(\\\"limit\\\", limit, [int, float]), (\\\"offset\\\", offset, [int,\",\n \"] ) assert self.isnum() or self.isdate(), TypeError( \\\"cut only works\",\n \"{}({} - {})\\\".format( \\\"{}\\\", cmin, \\\"NULLIFZERO\\\" if (nullifzero) else \\\"\\\",\",\n \"---# def aad(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using 'aad'\",\n \"/ / # |______ / / / # |____/ /\",\n \"(h > 1) or (self.category() == \\\"float\\\"): trans = (\",\n \"std : standard deviation topk : kth most occurent element\",\n \"query = \\\"WITH vdf_table AS (SELECT * FROM {}) {}\\\".format(\",\n \"be greater or equal to 2.\\\" ) assert len(breaks) ==\",\n \"Returns True if the vColumn category is date, False otherwise.\",\n \"the parent vDataFrame. Parameters ---------- name: str Name of the\",\n \"[name] conj = \\\"s were \\\" if len(all_new_features) > 1\",\n \"optional parameter to pass to the Matplotlib functions. Returns -------\",\n \"nbins if h > 0.01: h = round(h, 2) elif\",\n \"------- int vColumn expected store usage. See Also -------- vDataFrame.expected_store_usage\",\n \": Replaces the outliers by the NULL value. winsorize :\",\n \"=> {}\\\".format(distinct_elements[k], k) expr = \\\", \\\".join(expr) + \\\", {})\\\".format(len(distinct_elements))\",\n \"name=\\\"kde\\\") if isinstance(xlim, (tuple, list)): xlim_tmp = [xlim] else: xlim_tmp\",\n \"are in the vColumn and it returns the new vDataFrame\",\n \"NULL) VERTICAPY_SUBTABLE {}\\\".format( self.alias, self.alias, self.alias, self.parent.__genSQL__(), self.alias, where, )\",\n \"* sauv[\\\"count\\\"] / self.parent.shape()[0] ) for elem in sauv: if\",\n \"IS NOT NULL LIMIT 0\\\".format( func.replace(\\\"{}\\\", self.alias), self.parent.__genSQL__(), self.alias, ),\",\n \"method == \\\"is_numeric\\\" ): self.parent.__update_catalog__({\\\"index\\\": index, self.alias: result}) for elem\",\n \"'{second_elem}' THEN '{label}'\\\" ] expr = \\\"CASE WHEN \\\" +\",\n \"self elif method == \\\"minmax\\\": if n == 0: nullifzero\",\n \"NULL END)\\\" trans = (trans, \\\"varchar\\\", \\\"text\\\") if return_enum_trans: return\",\n \"): self.parent.__update_catalog__({\\\"index\\\": index, self.alias: result}) for elem in values: for\",\n \"= (None, None), ax=None, **style_kwds, ): \\\"\\\"\\\" --------------------------------------------------------------------------- Draws the\",\n \"to use to impute the missing values. auto : Mean\",\n \"input aggregations. \\\"\\\"\\\" return self.aggregate([\\\"count\\\"]).values[self.alias][0] # ---# def cut( self,\",\n \"if (self.category() == \\\"int\\\") else \\\"\\\" if (h > 1)\",\n \"# ---# def get_dummies( self, prefix: str = \\\"\\\", prefix_sep:\",\n \"int)): index_start = 0 if index_start < 0: index_start +=\",\n \"\\\"float\\\", ) ] else: warning_message = \\\"Can not normalize {}\",\n \"h = (self.max() - self.min()) * 1.01 / nbins if\",\n \"in executeSQL( query=query, title=\\\"Computing the average of the {}'s lower\",\n \"total = abs(self.count() - total) except Exception as e: self.transformations\",\n \"expression. Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].str_contains :\",\n \"trans = ( \\\"(CASE WHEN {} IN ({}) THEN {}\",\n \"in each of the vColumn record by an input value.\",\n \"# ---# def rename(self, new_name: str): \\\"\\\"\\\" --------------------------------------------------------------------------- Renames the\",\n \"{})\\\".format(\\\"{}\\\", expr) elif method == \\\"0ifnull\\\": new_column = \\\"DECODE({}, NULL,\",\n \"__nonzero__(self): return self.count() > 0 # ---# def __repr__(self): return\",\n \"self.parent.are_namecols_in(by) by = self.parent.format_colnames(by) from verticapy.plot import boxplot return boxplot(self,\",\n \"date. \\\"\\\"\\\" return self.category() in (\\\"float\\\", \\\"int\\\") # ---# def\",\n \"Encodes the vColumn with One-Hot Encoding. vDataFrame[].label_encode : Encodes the\",\n \"\\\"avg\\\"]).transpose().values p_alpha, p_1_alpha = ( -threshold * result[\\\"std\\\"][0] + result[\\\"avg\\\"][0],\",\n \"be filtered. ax: Matplotlib axes object, optional The axes to\",\n \") total, query, nth_elems = nb, [], [] while total\",\n \"Parameters ---------- val: list List of the different records. For\",\n \"\\\"x\\\"), self.alias.replace('\\\"', \\\"\\\") ) ) # ---# def apply_fun(self, func:\",\n \"skew = skewness # ---# def slice(self, length: int, unit:\",\n \"{})\\\".format( self.alias, \\\", \\\".join(by) ), ) else: cmax, cmin =\",\n \"name, [str])]) name = quote_ident(name.replace('\\\"', \\\"_\\\")) assert name.replace('\\\"', \\\"\\\"), EmptyParameter(\",\n \"-------- vDataFrame[].tail : Returns the a part of the vColumn.\",\n \"axes object See Also -------- vDataFrame.donut : Draws the donut\",\n \"for elem in order_by] for elem in all_partition: if len(self.parent[elem].transformations)\",\n \"and bools), a RF Classifier otherwise. Example: Write {\\\"n_estimators\\\": 20,\",\n \"AVG(column1) + 5). of: str, optional The vColumn to use\",\n \"): max_floor = max( len(self.parent[column].transformations), max_floor ) except: pass max_floor\",\n \"pre_comp != \\\"VERTICAPY_NOT_PRECOMPUTED\\\": return pre_comp assert self.isnum() or self.isdate(), ParameterError(\",\n \"analytics and machine learning features. It supports the # entire\",\n \"events, pt_non_events, pt_events, CASE WHEN non_events = 0 OR events\",\n \"\\\", \\\".join(by) ), \\\"STDDEV({}) OVER (PARTITION BY {})\\\".format( self.alias, \\\",\",\n \"= \\\"s were \\\" if total > 1 else \\\"\",\n \"--------------------------------------------------------------------------- Returns the k most occurent elements, how often they\",\n \"Converts the vColumns to the input type. \\\"\\\"\\\" check_types([(\\\"dtype\\\", dtype,\",\n \"custom_lines += [ Line2D( [0], [0], color=updated_dict(param, style_kwds, idx)[\\\"color\\\"], lw=4,\",\n \"return_enum_trans: return trans else: self.transformations += [trans] sauv = {}\",\n \"True if pie_type == \\\"donut\\\" else False rose = True\",\n \"method == \\\"winsorize\\\": self.clip(lower=p_alpha, upper=p_1_alpha) elif method == \\\"null\\\": self.apply(\",\n \"# ---# def str_contains(self, pat: str): \\\"\\\"\\\" --------------------------------------------------------------------------- Verifies if\",\n \"str, optional vColumn to use to partition the data. h:\",\n \"---------- limit: int, optional Number of elements to display. offset:\",\n \"memorize the already computed aggregations to gain in performance. The\",\n \"-------- vDataFrame.analytic : Adds a new vColumn to the vDataFrame\",\n \"value at risk dtype : vColumn type iqr : interquartile\",\n \"plot of the vColumn. The aggregations used are the median\",\n \"[self.alias] if add_history: self.parent.__add_to_history__( \\\"[Drop]: vColumn {} was deleted from\",\n \"see utilities.tablesample. See Also -------- vDataFrame[].head : Returns the head\",\n \") self.catalog = { \\\"cov\\\": {}, \\\"pearson\\\": {}, \\\"spearman\\\": {},\",\n \"int = 5, offset: int = 0): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns\",\n \"numerical\\\" ) cast = \\\"::int\\\" if (self.parent[numcol].isbool()) else \\\"\\\" query,\",\n \"Returns ------- float sem See Also -------- vDataFrame.aggregate : Computes\",\n \"Also -------- vDataFrame[].str_contains : Verifies if the regular expression is\",\n \"sinh : hyperbolic sine sqrt : arithmetic square root tan\",\n \"{}) / {} < {}\\\".format( self.alias, result[\\\"avg\\\"][0], result[\\\"std\\\"][0], threshold )\",\n \"): \\\"\\\"\\\" --------------------------------------------------------------------------- Encodes the vColumn with the One-Hot Encoding\",\n \"1) and (method != \\\"numerical\\\")) or not (is_numeric) or (method\",\n \"self.parent.__add_to_history__( \\\"[Normalize]: The vColumn '{}' was normalized with the method\",\n \"else prefix.replace('\\\"', \\\"_\\\") + prefix_sep.replace('\\\"', \\\"_\\\") ) n = 1\",\n \"considered during the computation. Returns ------- tablesample An object containing\",\n \"the vColumn from the vDataFrame. Dropping a vColumn means simply\",\n \": Replaces the upper and lower outliers by their respective\",\n \"to_replace: str Regular expression to replace. value: str, optional New\",\n \"# / / # / / # \\\\ / #\",\n \"index_start = index.start if not (isinstance(index_start, int)): index_start = 0\",\n \"vDataFrame.astype : Converts the vColumns to the input type. \\\"\\\"\\\"\",\n \"elem in self.catalog: total += sys.getsizeof(elem) return total # ---#\",\n \"optional The method to use to aggregate the data. count\",\n \"bool = False, n: int = 1): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns\",\n \"elem in result] ), ) executeSQL( \\\"SELECT {} FROM {}\",\n \"\\\"Reads {}.\\\".format(self.alias) tail = to_tablesample( \\\"SELECT {} AS {} FROM\",\n \"been transformed multiple times, so it's better practice to use\",\n \"{}) / {}({} - {})\\\".format( self.alias, cmin, \\\"NULLIFZERO\\\" if (nullifzero)\",\n \"not be considered during the computation. n: int, optional Integer\",\n \"MAX. MAX = MIN !\\\".format( self.alias ) warnings.warn(warning_message, Warning) return\",\n \"self.alias, self.parent.__genSQL__(), by[0], ), title=\\\"Computing the different categories to normalize.\\\",\",\n \"def hist( self, method: str = \\\"density\\\", of: str =\",\n \"date, optional Input Start Date. For example, time = '03-11-1993'\",\n \"drop(tmp_model_name, method=\\\"model\\\") if self.parent[response].category() == \\\"float\\\": model = RandomForestRegressor(tmp_model_name) else:\",\n \"assert order_by, ParameterError( \\\"If the method is in ffill|pad|bfill|backfill then\",\n \"(PARTITION BY {})\\\".format( self.alias, \\\", \\\".join(by) ), \\\"STDDEV({}) OVER (PARTITION\",\n \"\\\"\\\", return_enum_trans: bool = False, ): \\\"\\\"\\\" --------------------------------------------------------------------------- Discretizes the\",\n \"[str]), (\\\"kernel\\\", kernel, [\\\"gaussian\\\", \\\"logistic\\\", \\\"sigmoid\\\", \\\"silverman\\\"]), (\\\"bandwidth\\\", bandwidth, [int,\",\n \"November 1993 the 3rd. plot_median: bool, optional If set to\",\n \"[ (\\\"breaks\\\", breaks, [list]), (\\\"labels\\\", labels, [list]), (\\\"include_lowest\\\", include_lowest, [bool]),\",\n \"10): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns the n largest vColumn elements. Parameters\",\n \"self.alias, name ) ) return self.parent # ---# def aggregate(self,\",\n \"self.alias, self.parent.__genSQL__(), self.alias, where, ) result = executeSQL( query=query, title=\\\"Computing\",\n \"of discretization using the method 'same_freq'\\\" ) count = self.count()\",\n \": standard error of the mean skewness : skewness sum\",\n \"to sort the data when using TS methods. Returns -------\",\n \": Freedman Diaconis [2 * IQR / n ** (1\",\n \"use to impute the missing values. auto : Mean for\",\n \"A float between 0 and 1 that represents the quantile.\",\n \"1 (1 meaning global outlier). \\\"\\\"\\\" check_types( [ (\\\"alpha\\\", alpha,\",\n \"decimal, warnings, datetime from collections.abc import Iterable from typing import\",\n \"to the upper bound itself. Parameters ---------- lower: float, optional\",\n \"columns=[self.alias], unique=False ) .transpose() .values[self.alias] ) result = [distinct_count] +\",\n \") return self.parent # ---# def fillna( self, val=None, method:\",\n \"self.category()) ] self.parent[copy_name].transformations += [(func, ctype, category)] self.parent[copy_name].catalog = self.catalog\",\n \"vDataFrame self.parent See Also -------- vDataFrame.fill_outliers : Fills the outliers\",\n \"the Z-Score (avg and std). (x - avg) / std\",\n \"5): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns the tail of the vColumn. Parameters\",\n \"USING PARAMETERS percentile = 0.5) AS 'approx_50%', APPROXIMATE_PERCENTILE ({3}{4} USING\",\n \"for i in range(parameters[\\\"n_estimators\\\"]) ] query = \\\"SELECT split_value FROM\",\n \"(\\\"threshold\\\", threshold, [int, float]), ] ) if use_threshold: result =\",\n \"vColumn memory usage (byte) See Also -------- vDataFrame.memory_usage : Returns\",\n \"For more information, see utilities.tablesample. See Also -------- vDataFrame[].head :\",\n \"trans = (\\\"{} || ''\\\", \\\"varchar\\\", \\\"text\\\") if (self.isnum() and\",\n \"\\\"{}\\\" ) ) return self.parent # ---# def fillna( self,\",\n \"if self.parent[response].category() == \\\"float\\\": model = RandomForestRegressor(tmp_model_name) else: model =\",\n \"method: str, optional Method to use to compute the optimal\",\n \"self.alias) return to_tablesample(query, title=title) # ---# def numh(self, method: str\",\n \"Interval width of the bar. If empty, an optimized h\",\n \"the values higher than the upper bound to the upper\",\n \"\\\"MEDIAN\\\": fun = \\\"APPROXIMATE_MEDIAN\\\" query = \\\"SELECT {}, {}({}) FROM\",\n \"self.distinct() if distinct_elements not in ([0, 1], [1, 0]) or\",\n \"vColumn to use to partition the data. h: float, optional\",\n \"== None: self.catalog[elem] = None elif method == \\\"robust_zscore\\\": self.catalog[elem]\",\n \"method == \\\"robust_zscore\\\": self.catalog[\\\"median\\\"] = 0 self.catalog[\\\"mad\\\"] = 1 /\",\n \"val, [list])]) val = {self.alias: val} return self.parent.isin(val) # ---#\",\n \"optional The vColumn to use to compute the aggregation. max_cardinality:\",\n \"val) elif (len(by) == 1) and (self.parent[by[0]].nunique() < 50): try:\",\n \"self.alias, avg, \\\"NULLIFZERO\\\" if (nullifzero) else \\\"\\\", stddev ) else:\",\n \"Parameters ---------- n: int Number of digits to keep after\",\n \"\\\"\\\"\\\" --------------------------------------------------------------------------- Returns the category of the vColumn. The category\",\n \"to extract. It must be one of the following: CENTURY\",\n \"at least one element to use to order the data\\\"\",\n \"index.stop index_start = index.start if not (isinstance(index_start, int)): index_start =\",\n \"Box Plot of the input vColumns. \\\"\\\"\\\" if isinstance(cat_priority, str)\",\n \"Outliers. \\\"\\\"\\\" if isinstance(by, str): by = [by] check_types( [\",\n \"= {}, response: str = \\\"\\\", return_enum_trans: bool = False,\",\n \"no mode (only missing values).\\\\nNothing was filled.\\\".format( self.alias ) warnings.warn(warning_message,\",\n \": Uses popular numerical aggregations during the computation. max_cardinality: int,\",\n \"numerical , 'categorical' otherwise. categorical : Uses only categorical aggregations\",\n \") cmin = \\\"DECODE({}, {}, NULL)\\\".format( by[0], \\\", \\\".join( [\",\n \"See Also -------- vDataFrame[].str_contains : Verifies if the regular expression\",\n \"absolute value function to the input vColumn. Returns ------- vDataFrame\",\n \"spider plot of the input vColumn based on an aggregation.\",\n \"query = \\\"SELECT {}, {}({}) FROM {} GROUP BY {};\\\".format(\",\n \"[0], color=updated_dict(param, style_kwds, idx)[\\\"color\\\"], lw=4, ), ] ax.set_title(\\\"KernelDensity\\\") ax.legend( custom_lines,\",\n \"and (numcol != \\\"\\\"): numcol = self.parent.format_colnames(numcol) assert self.parent[numcol].category() in\",\n \"= \\\"\\\", max_cardinality: int = 6, h: float = 0,\",\n \"offset and a limit). Parameters ---------- limit: int, optional Number\",\n \"nbins: int = -1, k: int = 6, new_category: str\",\n \"add_history: self.parent.__add_to_history__( \\\"[Drop]: vColumn {} was deleted from the vDataFrame.\\\".format(self.alias)\",\n \"the final generated SQL code. Note: Dropping a vColumn can\",\n \"= [], return_trans: bool = False ): \\\"\\\"\\\" --------------------------------------------------------------------------- Normalizes\",\n \"is date. \\\"\\\"\\\" return self.category() in (\\\"float\\\", \\\"int\\\") # ---#\",\n \"vdf_table AS (SELECT * FROM {}) (SELECT AVG({}) FROM vdf_table\",\n \"---------- method: str, optional The describe method. auto : Sets\",\n \"data when using TS methods. Returns ------- vDataFrame self.parent See\",\n \"in range(len(distinct_elements)): expr += [ \\\"'{}', {}\\\".format(str(distinct_elements[k]).replace(\\\"'\\\", \\\"''\\\"), k) ]\",\n \"by[0] ), method=\\\"fetchall\\\", ) cmin = \\\"DECODE({}, {}, NULL)\\\".format( by[0],\",\n \"the input vColumn. Returns ------- vDataFrame self.parent See Also --------\",\n \"will be considered as an outlier. use_threshold: bool, optional Uses\",\n \"the Apache License, Version 2.0 (the \\\"License\\\"); # You may\",\n \"of the vColumn 'of' (ex: 50% to get the median).\",\n \"the specified name. \\\\u26A0 Warning : SQL code generation will\",\n \"float]), (\\\"dropna\\\", dropna, [bool])]) topk = \\\"\\\" if (k <\",\n \"See Also -------- vDataFrame[].decode : Encodes the vColumn with user\",\n \"NULL END)\\\".format( \\\"{}\\\", p_alpha, p_1_alpha, \\\"{}\\\" ) ) elif method\",\n \"result = executeSQL( \\\"SELECT {}, AVG({}), STDDEV({}) FROM {} GROUP\",\n \"None else \\\"NULL\\\", ) for elem in result if elem[1]\",\n \"vColumn_min) / int(math.floor(math.log(count, 2) + 2)), 1e-99, ) fd =\",\n \"+= self.parent.shape()[0] limit = index_stop - index_start if limit <=\",\n \"Labels used to name the new categories. If empty, names\",\n \"hist(self, method, of, max_cardinality, nbins, h, ax=ax, **style_kwds) # ---#\",\n \"empty, an optimized h will be computed. pie_type: str, optional\",\n \"\\\"auto\\\": pre_comp = self.parent.__get_catalog_value__(self.alias, \\\"numh\\\") if pre_comp != \\\"VERTICAPY_NOT_PRECOMPUTED\\\": return\",\n \"using the floor of the slicing instead of the ceiling.\",\n \"xlim_tmp = [] model = KernelDensity( name, bandwidth=bandwidth, kernel=kernel, nbins=nbins,\",\n \"[item for sublist in query_result for item in sublist] #\",\n \"method=\\\"numerical\\\", columns=[self.alias], unique=False ) .transpose() .values[self.alias] ) count, vColumn_min, vColumn_025,\",\n \"else \\\"\\\", stddev ), \\\"float\\\", \\\"float\\\", ) ] elif method\",\n \"optional Maximum number of vColumn distinct elements to be used\",\n \"the head of the vColumn. vDataFrame[].tail : Returns the tail\",\n \"pre-computed aggregations. parent, vDataFrame : Parent of the vColumn. transformations,\",\n \"outlier). \\\"\\\"\\\" check_types( [ (\\\"alpha\\\", alpha, [int, float]), (\\\"use_threshold\\\", use_threshold,\",\n \"use to determine if the vColumn will be considered as\",\n \"nb where = \\\"WHERE _verticapy_row_nb_ IN ({})\\\".format( \\\", \\\".join([\\\"1\\\"] +\",\n \"------- float var See Also -------- vDataFrame.aggregate : Computes the\",\n \"/ self.parent.shape()[0] ) for elem in sauv: if \\\"top\\\" in\",\n \"dummies. prefix_sep: str, optional Prefix delimitor of the dummies. drop_first:\",\n \"the input vColumn. \\\"\\\"\\\" check_types([(\\\"x\\\", x, [int, float])]) if self.isdate():\",\n \"AS pt_non_events, events / NULLIFZERO(SUM(events) OVER ()) AS pt_events FROM\",\n \"\\\"std\\\", \\\"min\\\", \\\"approx_25%\\\", \\\"approx_50%\\\", \\\"approx_75%\\\", \\\"max\\\", ] if method !=\",\n \"time of the learning and scoring phases. xlim: tuple, optional\",\n \"({}) x GROUP BY 1\\\".format( self.alias, y, y, query, )\",\n \"vColumns, cast the other types to varchar. same_freq : Computes\",\n \"* FROM {}) (SELECT AVG({}) FROM vdf_table WHERE {} <\",\n \"= False if check: self.parent.are_namecols_in(column) column = self.parent.format_colnames(column) columns +=\",\n \"nunique(self, approx: bool = True): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn\",\n \"= 0 OR events = 0 THEN 0 ELSE ZEROIFNULL(LN(pt_non_events\",\n \"'var' (Variance). Returns ------- float var See Also -------- vDataFrame.aggregate\",\n \"the input Name. Returns ------- vDataFrame self.parent See Also --------\",\n \"GROUP BY {};\\\".format( by[0], fun, self.alias, self.parent.__genSQL__(), by[0] ) result\",\n \"functions. Returns ------- ax Matplotlib axes object See Also --------\",\n \"gathered together to create a new category : 'Others'. cat_priority:\",\n \"input type. \\\"\\\"\\\" check_types([(\\\"dtype\\\", dtype, [str])]) try: query = \\\"SELECT\",\n \"\\\\ \\\\-. \\\\ # \\\\ \\\\__| \\\\ \\\\_____\\\\ \\\\ \\\\_____\\\\\",\n \"\\\\ \\\\ \\\\-. \\\\ # \\\\ \\\\__| \\\\ \\\\_____\\\\ \\\\\",\n \"chart of the vColumn based on an aggregation. Parameters ----------\",\n \"a numerical column for each vColumn category. In this case,\",\n \"method, [\\\"sturges\\\", \\\"freedman_diaconis\\\", \\\"fd\\\", \\\"auto\\\"])] ) method = method.lower() if\",\n \"'topk'\\\" ) distinct = self.topk(k).values[\\\"index\\\"] trans = ( \\\"(CASE WHEN\",\n \"\\\"top\\\" in elem: if \\\"percent\\\" in elem: self.catalog[elem] = sauv[elem]\",\n \"the bar. If empty, an optimized h will be computed.\",\n \"of the slicing. step: int Size of the slicing. Returns\",\n \"(\\\"same_width\\\", \\\"auto\\\"): if not (h) or h <= 0: if\",\n \"\\\"\\\"\\\" check_types([(\\\"lower\\\", lower, [float, int]), (\\\"upper\\\", upper, [float, int])]) assert\",\n \"Interval width if the vColumn is numerical or of type\",\n \"the already computed aggregations to gain in performance. The catalog\",\n \"method = \\\"mean\\\" if (self.isnum() and self.nunique(True) > 6) else\",\n \"use to fill the vColumn outliers. mean : Replaces the\",\n \"the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required\",\n \": Encodes the vColumn with One-Hot Encoding. \\\"\\\"\\\" check_types([(\\\"response\\\", response,\",\n \") else: query = \\\"SELECT PERCENTILE_CONT({}) WITHIN GROUP (ORDER BY\",\n \"License. # You may obtain a copy of the License\",\n \"decimal.Decimal): values[elem][i] = float(values[elem][i]) return tablesample(values) # ---# def discretize(\",\n \"{}' to '{}'\\\".format( e, func.replace(\\\"{}\\\", \\\"x\\\"), self.alias.replace('\\\"', \\\"\\\") ) )\",\n \"max FROM {}\\\".format( self.alias, self.alias, self.alias, self.alias, self.alias, table )\",\n \"Draws the Time Series of the vColumn. Parameters ---------- ts:\",\n \"to the vColumn {}\\\\n{} feature{}created: {}\\\".format( self.alias, len(all_new_features), conj, \\\",\",\n \"Union[int, float, tuple] = (None, None), ax=None, **style_kwds, ): \\\"\\\"\\\"\",\n \"\\\"{}\\\", p_alpha, mean_alpha, \\\"{}\\\", p_1_alpha, mean_1_alpha, \\\"{}\\\" ) ) return\",\n \"(No h will be picked or computed) ax: Matplotlib axes\",\n \"( \\\"func\\\", func, [ \\\"abs\\\", \\\"acos\\\", \\\"asin\\\", \\\"atan\\\", \\\"cbrt\\\", \\\"ceil\\\",\",\n \"computed if the parameter is empty or invalid. max_cardinality: int/tuple,\",\n \"self.clip(lower=p_alpha, upper=p_1_alpha) elif method == \\\"null\\\": self.apply( func=\\\"(CASE WHEN ({}\",\n \"return pie( self, method, of, max_cardinality, h, donut, rose, ax=None,\",\n \"(PARTITION BY {})\\\".format( self.alias, \\\", \\\".join(by) ), \\\"MIN({}) OVER (PARTITION\",\n \"float mad See Also -------- vDataFrame.aggregate : Computes the vDataFrame\",\n \"be considered as an outlier. use_threshold: bool, optional Uses the\",\n \": Computes the vDataFrame input aggregations. \\\"\\\"\\\" return self.aggregate([\\\"skewness\\\"]).values[self.alias][0] skew\",\n \"({} BETWEEN {} AND {}) THEN {} ELSE NULL END)\\\".format(\",\n \"prefix_sep: str = \\\"_\\\", drop_first: bool = True, use_numbers_as_suffix: bool\",\n \"generated will look like: even: CASE ... WHEN vColumn =\",\n \"for elem in self.catalog: sauv[elem] = self.catalog[elem] self.parent.__update_catalog__(erase=True, columns=[self.alias]) try:\",\n \"= \\\"\\\" query = \\\"(SELECT {} FROM {}{} OFFSET {}{})\",\n \"\\\"AVG\\\" if by == []: if fun == \\\"AVG\\\": val\",\n \"import KernelDensity schema = verticapy.options[\\\"temp_schema\\\"] if not (schema): schema =\",\n \"--------------------------------------------------------------------------- Aggregates the vColumn using 'mad' (median absolute deviation). Returns\",\n \"or one of its affiliates. # Licensed under the Apache\",\n \"(must be > 1) Returns ------- tablesample An object containing\",\n \"h > 0.0001: h = round(h, 4) elif h >\",\n \": Returns the n largest vColumn elements. \\\"\\\"\\\" check_types([(\\\"n\\\", n,\",\n \"= \\\"public\\\" name = gen_tmp_name(schema=schema, name=\\\"kde\\\") if isinstance(xlim, (tuple, list)):\",\n \"(Average Absolute Deviation). Returns ------- float aad See Also --------\",\n \"result = executeSQL( query=query, title=\\\"Computing the equal frequency histogram bins.\\\",\",\n \"nbins=nbins, k=nbins, new_category=\\\"Others\\\", return_enum_trans=True, )[0].replace(\\\"{}\\\", self.alias) query = \\\"SELECT {}\",\n \"{} named {} was added to the vDataFrame.\\\".format( self.alias, name\",\n \"aggregations. \\\"\\\"\\\" return self.aggregate([\\\"count\\\"]).values[self.alias][0] # ---# def cut( self, breaks:\",\n \"ax=None, **style_kwds, ): \\\"\\\"\\\" --------------------------------------------------------------------------- Draws the pie chart of\",\n \"raise ConversionError( \\\"{}\\\\nThe vColumn {} can not be converted to\",\n \"input vColumn. \\\"\\\"\\\" check_types([(\\\"x\\\", x, [int, float])]) if self.isdate(): return\",\n \"(function, type, category) parent: vDataFrame, optional Parent of the vColumn.\",\n \"numcol: str = \\\"\\\" ): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn\",\n \"PARAMETERS percentile = 0.25) AS Q1, APPROXIMATE_PERCENTILE({} USING PARAMETERS percentile\",\n \"limits of the current axes. ax: Matplotlib axes object, optional\",\n \"NAs, MIN({}) AS min, APPROXIMATE_PERCENTILE({} USING PARAMETERS percentile = 0.25)\",\n \"quantiles used to draw the Plot. start_date: str / date,\",\n \"in relation to the dependent variable. Parameters ---------- y: str\",\n \"elements). Returns ------- int number of non-Missing elements. See Also\",\n \"tablesample(values) # ---# def value_counts(self, k: int = 30): \\\"\\\"\\\"\",\n \"vDataFrame[].isnum : Returns True if the vColumn is numerical. \\\"\\\"\\\"\",\n \"Encoding. vDataFrame[].discretize : Discretizes the vColumn. vDataFrame[].label_encode : Encodes the\",\n \"\\\"count\\\": self.parent.shape()[0], \\\"percent\\\": 100.0, \\\"unique\\\": 2, \\\"approx_unique\\\": 2, \\\"prod\\\": 0,\",\n \"approx: bool, optional If set to True, the approximate median\",\n \"None) or (upper != None), ParameterError( \\\"At least 'lower' or\",\n \"Name of the copy. Returns ------- vDataFrame self.parent See Also\",\n \"the floor of the slicing instead of the ceiling. Returns\",\n \"the length of parameter 'labels' + 1 or parameter 'labels'\",\n \": Adds a new vColumn labeled with 0 and 1\",\n \"self.avg() elif fun == \\\"MEDIAN\\\": val = self.median() new_column =\",\n \"method in [\\\"ffill\\\", \\\"pad\\\", \\\"bfill\\\", \\\"backfill\\\"]: all_partition += [elem for\",\n \"picked or computed) nbins: int, optional Number of bins. If\",\n \") assert response, ParameterError( \\\"Parameter 'response' can not be empty\",\n \"= \\\"<=\\\", \\\"<\\\", \\\"[\\\", \\\"[\\\" if idx == 0 and\",\n \"elif (method == \\\"cat_stats\\\") and (numcol != \\\"\\\"): numcol =\",\n \"The new vColumn alias. Returns ------- vDataFrame self.parent See Also\",\n \"{})\\\".format(x, \\\"{}\\\")) else: return self.apply(func=\\\"{} - ({})\\\".format(\\\"{}\\\", x)) # ---#\",\n \"Parameters ---------- pat: str Regular expression. Returns ------- vDataFrame self.parent\",\n \"pie chart. auto : Regular pie chart. donut : Donut\",\n \"Parameters ---------- argv: object Any amount of expressions. The expression\",\n \"RandomForestClassifier(tmp_model_name) model.set_params({\\\"n_estimators\\\": 20, \\\"max_depth\\\": 8, \\\"nbins\\\": 100}) model.set_params(RFmodel_params) parameters =\",\n \"= str(func) check_types([(\\\"func\\\", func, [str]), (\\\"copy_name\\\", copy_name, [str])]) try: try:\",\n \"best_h = max(sturges, fd) self.parent.__update_catalog__({\\\"index\\\": [\\\"numh\\\"], self.alias: [best_h]}) if self.category()\",\n \"# ---# def label_encode(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Encodes the vColumn using\",\n \"] force_columns.remove(self.alias) executeSQL( \\\"SELECT * FROM {} LIMIT 10\\\".format( self.parent.__genSQL__(force_columns=force_columns)\",\n \"hot encoder was applied to the vColumn {}\\\\n{} feature{}created: {}\\\".format(\",\n \"self.parent.are_namecols_in(of) of = self.parent.format_colnames(of) from verticapy.plot import spider as spider_plot\",\n \"sqrt : arithmetic square root tan : trigonometric tangent tanh\",\n \"next whole number cos : trigonometric cosine cosh : hyperbolic\",\n \"(\\\"mean\\\", \\\"avg\\\", \\\"median\\\"): fun = \\\"MEDIAN\\\" if (method == \\\"median\\\")\",\n \"int = 10): \\\"\\\"\\\" --------------------------------------------------------------------------- Computes the Information Value (IV)\",\n \"standard error of the mean skewness : skewness sum :\",\n \"\\\" was \\\" if verticapy.options[\\\"print_info\\\"]: print(\\\"{} element{}filled.\\\".format(total, conj)) self.parent.__add_to_history__( \\\"[Fillna]:\",\n \"= \\\", \\\".join([quote_ident(column) + desc for column in order_by]) new_column\",\n \"is numerical. \\\"\\\"\\\" return self.category() == \\\"date\\\" # ---# def\",\n \"Set the x limits of the current axes. ax: Matplotlib\",\n \"nbins <= 0: h = self.numh() else: h = (self.max()\",\n \"list, labels: list = [], include_lowest: bool = True, right:\",\n \"== \\\"MEDIAN\\\": val = self.median() new_column = \\\"COALESCE({}, {})\\\".format(\\\"{}\\\", val)\",\n \"!= None else \\\"NULL\\\", elem[2] if elem[2] != None else\",\n \"vdf_table\\\"\\\"\\\".format( category, self.alias, self.parent.shape()[0], numcol, cast, ) tmp_query += (\",\n \"unique=False ) .transpose() .values[self.alias] ) count, vColumn_min, vColumn_025, vColumn_075, vColumn_max\",\n \"current vColumn and creating a copy with the specified name.\",\n \"WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\",\n \"records. The vColumn will be transformed. Parameters ---------- pat: str\",\n \"idx, elem in enumerate(result): result[idx][0] = ( \\\"NULL\\\" if (elem[0]\",\n \"the geopandas plot function. For more information, see: https://geopandas.readthedocs.io/en/latest/docs/reference/api/ geopandas.GeoDataFrame.plot.html\",\n \"the function's performance can drastically decrease. Returns ------- float/str median\",\n \"in range(parameters[\\\"n_estimators\\\"]) ] query = \\\"SELECT split_value FROM (SELECT split_value,\",\n \"prefix: str, optional Prefix of the dummies. prefix_sep: str, optional\",\n \"the average of the response partitioned by the different vColumn\",\n \"input aggregations. \\\"\\\"\\\" check_types([(\\\"x\\\", x, [int, float], (\\\"approx\\\", approx, [bool]))])\",\n \"Parameters ---------- method: str, optional The method to use to\",\n \"), \\\"varchar\\\", \\\"text\\\", ) else: trans = (\\\"FLOOR({}) || ''\\\",\",\n \"= self.aggregate(func=[\\\"std\\\", \\\"avg\\\"]).transpose().values p_alpha, p_1_alpha = ( -threshold * result[\\\"std\\\"][0]\",\n \"\\\"value\\\": [self.alias, self.ctype()] + result, } if ((is_date) and not\",\n \"number of non-Missing elements. See Also -------- vDataFrame.aggregate : Computes\",\n \"\\\"\\\"\\\" check_types( [ (\\\"by\\\", by, [str]), (\\\"kernel\\\", kernel, [\\\"gaussian\\\", \\\"logistic\\\",\",\n \"vColumn using 'sum'. Returns ------- float sum See Also --------\",\n \"str Regular expression. Returns ------- vDataFrame self.parent See Also --------\",\n \"algorithm. Parameters ---------- prefix: str, optional Prefix of the dummies.\",\n \"works on numerical / date-like vColumns.\\\" ) assert len(breaks) >=\",\n \"else False rose = True if pie_type == \\\"rose\\\" else\",\n \"spider_plot return spider_plot( self.parent, columns, method, of, max_cardinality, h, ax=ax,\",\n \"of the vColumn 'of'. sum : Sum of the vColumn\",\n \"draw a Step Plot. ax: Matplotlib axes object, optional The\",\n \"required by applicable law or agreed to in writing, software\",\n \"Version 2.0 (the \\\"License\\\"); # You may not use this\",\n \"THEN {} \\\".format(\\\"{}\\\", upper, upper) if (isinstance(upper, (float, int))) else\",\n \"/ / / # \\\\ / / / # \\\\/\",\n \"Table. \\\"\\\"\\\" check_types([(\\\"y\\\", y, [str]), (\\\"nbins\\\", nbins, [int])]) self.parent.are_namecols_in(y) y\",\n \"axes object, optional The axes to plot on. **style_kwds Any\",\n \"iloc(self, limit: int = 5, offset: int = 0): \\\"\\\"\\\"\",\n \"Number of most occurent elements to return. dropna: bool, optional\",\n \"(\\\"cat_priority\\\", cat_priority, [list]), ] ) if by: self.parent.are_namecols_in(by) by =\",\n \"{})\\\".format( self.alias, \\\", \\\".join(by) ), ) else: avg, stddev =\",\n \"variable in relation to the dependent variable. Parameters ---------- y:\",\n \"the vDataFrame input aggregations. \\\"\\\"\\\" check_types([(\\\"x\\\", x, [int, float], (\\\"approx\\\",\",\n \"# # # Modules # # Standard Python Modules import\",\n \"\\\"[Get Dummies]: One hot encoder was applied to the vColumn\",\n \"agreed to in writing, software # distributed under the License\",\n \"the input vColumn. \\\"\\\"\\\" check_types([(\\\"x\\\", x, [int, float])]) return self.apply(func=\\\"{}\",\n \": Extracts a specific TS field from the vColumn. \\\"\\\"\\\"\",\n \"Parameters ---------- approx: bool, optional If set to True, the\",\n \"using an input 'quantile'. Parameters ---------- x: float A float\",\n \"0: if return_trans: return \\\"({} - {}) / ({})\\\".format(self.alias, med,\",\n \"[self.alias, by] else: columns = [self.alias] if of: self.parent.are_namecols_in(of) of\",\n \"+ \\\".\\\" ) return self.parent one_hot_encode = get_dummies # ---#\",\n \"True if the vColumn is boolean. vDataFrame[].isnum : Returns True\",\n \"**style_kwds, ) # ---# def product(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the\",\n \"one vColumn can only have one parent. catalog: dict, optional\",\n \"rule. \\\"\\\"\\\" return self.apply(func=\\\"DATE_PART('{}', {})\\\".format(field, \\\"{}\\\")) # ---# def decode(self,\",\n \"Evidence (WOE) Table. It tells the predictive power of an\",\n \"in the vColumn. You can write the following list: [\\\"Fouad\\\",\",\n \"record of the vColumn. vDataFrame[].str_slice : Slices the vColumn. \\\"\\\"\\\"\",\n \"elif (len(by) == 1) and (self.parent[by[0]].nunique() < 50): try: if\",\n \"bool, optional If set to True, the approximate cardinality is\",\n \"\\\"\\\"\\\" --------------------------------------------------------------------------- Draws the histogram of the vColumn based on\",\n \"(nullifzero) else \\\"\\\", cmax, cmin, ), \\\"float\\\", \\\"float\\\", ) ]\",\n \"time = '03-11-1993' will filter the data when 'ts' is\",\n \"Applies a function to the input vColumn. \\\"\\\"\\\" check_types([(\\\"x\\\", x,\",\n \"Parameters ---------- dtype: str New type. Returns ------- vDataFrame self.parent\",\n \"than quantile(alpha) or greater than quantile(1-alpha) will be filled. Returns\",\n \"to the next whole number cos : trigonometric cosine cosh\",\n \"= ( 100 * sauv[\\\"count\\\"] / self.parent.shape()[0] ) except: pass\",\n \"func ) ): max_floor = max( len(self.parent[column].transformations), max_floor ) except:\",\n \"Jarque-Bera index mad : median absolute deviation max : maximum\",\n \"popular numerical aggregations during the computation. max_cardinality: int, optional Cardinality\",\n \"{}\\\".format( self.alias, self.alias, self.alias, self.alias, self.alias, table ) result =\",\n \"numerical. by: str, optional vColumn to use to partition the\",\n \"specific TS field from the vColumn (only if the vColumn\",\n \"1, 0)\\\".format( \\\"{}\\\", str(distinct_elements[k]).replace(\\\"'\\\", \\\"''\\\") ) transformations = self.transformations +\",\n \"Input End Date. For example, time = '03-11-1993' will filter\",\n \"by evaluating some conditions. vDataFrame[].discretize : Discretizes the vColumn. vDataFrame[].label_encode\",\n \"10} to train a Random Forest with 20 trees and\",\n \"Returns ------- vDataFrame self.parent See Also -------- vDataFrame.fill_outliers : Fills\",\n \"Write {\\\"n_estimators\\\": 20, \\\"max_depth\\\": 10} to train a Random Forest\",\n \"vColumn. \\\"\\\"\\\" check_types([(\\\"n\\\", n, [int, float])]) return self.apply(func=\\\"ROUND({}, {})\\\".format(\\\"{}\\\", n))\",\n \"# ---# def tail(self, limit: int = 5): \\\"\\\"\\\" ---------------------------------------------------------------------------\",\n \"the vDataFrame input aggregations. \\\"\\\"\\\" check_types([(\\\"dropna\\\", dropna, [bool]), (\\\"n\\\", n,\",\n \"float std See Also -------- vDataFrame.aggregate : Computes the vDataFrame\",\n \"different categories {} to normalize.\\\".format( by[0] ), method=\\\"fetchall\\\", ) cmin\",\n \"product See Also -------- vDataFrame.aggregate : Computes the vDataFrame input\",\n \"Fills the vColumn outliers using the input method. \\\"\\\"\\\" check_types([(\\\"lower\\\",\",\n \"order_by: list, optional List of the vColumns to use to\",\n \"The method to use to discretize the vColumn. auto :\",\n \"elif method == \\\"zscore\\\": self.catalog[\\\"mean\\\"] = 0 self.catalog[\\\"std\\\"] = 1\",\n \"except: avg, stddev = ( \\\"AVG({}) OVER (PARTITION BY {})\\\".format(\",\n \"the threshold, it will be considered as an outlier. use_threshold:\",\n \"\\\"\\\"\\\" import sys total = ( sys.getsizeof(self) + sys.getsizeof(self.alias) +\",\n \"utilities.tablesample. See Also -------- vDataFrame.aggregate : Computes the vDataFrame input\",\n \"------- float std See Also -------- vDataFrame.aggregate : Computes the\",\n \"function to the input vColumn. \\\"\\\"\\\" check_types([(\\\"x\\\", x, [int, float])])\",\n \"PERCENTILE_CONT({}) WITHIN GROUP (ORDER BY {}) OVER (), PERCENTILE_CONT(1 -\",\n \"list, optional List of the different categories to consider when\",\n \"for categorical variables.\\\" ) warnings.warn(warning_message, Warning) else: distinct_elements = self.distinct()\",\n \"method in (\\\"mean\\\", \\\"avg\\\", \\\"median\\\"): fun = \\\"MEDIAN\\\" if (method\",\n \"to display. Returns ------- tablesample An object containing the result.\",\n \"= \\\"The method 'robust_zscore' is available only if the parameter\",\n \"vColumn to use to order the data. The vColumn type\",\n \"= True, use_numbers_as_suffix: bool = False, ): \\\"\\\"\\\" --------------------------------------------------------------------------- Encodes\",\n \"best_h # ---# def nunique(self, approx: bool = True): \\\"\\\"\\\"\",\n \"if elem[2] != None ] ), ) executeSQL( \\\"SELECT {},\",\n \"b). Returns ------- int vColumn expected store usage. See Also\",\n \"): \\\"\\\"\\\" --------------------------------------------------------------------------- Fills missing elements in the vColumn with\",\n \"try: if fun == \\\"MEDIAN\\\": fun = \\\"APPROXIMATE_MEDIAN\\\" query =\",\n \"{} AND {} THEN '[{};{}]' \\\".format( \\\"{}\\\", result[i - 1],\",\n \"ffill : Propagation of the first element (Constant Interpolation). mean\",\n \": Slices the vColumn. \\\"\\\"\\\" check_types([(\\\"to_replace\\\", to_replace, [str]), (\\\"value\\\", value,\",\n \"Returns True if the vColumn category is date. \\\"\\\"\\\" return\",\n \"nullifzero, n = 1, len(by) if self.isbool(): warning_message = \\\"Normalize\",\n \"= self.alias return tail # ---# def isbool(self): \\\"\\\"\\\" ---------------------------------------------------------------------------\",\n \"most occurent element percent : percent of non-missing elements q%\",\n \"kernel. sigmoid : Sigmoid kernel. silverman : Silverman kernel. nbins:\",\n \": Returns the vDataFrame memory usage. \\\"\\\"\\\" import sys total\",\n \"response_cat = self.parent[y].distinct() response_cat.sort() assert response_cat == [0, 1], TypeError(\",\n \"< 1) else \\\"LIMIT {}\\\".format(k) dropna = \\\" WHERE {}\",\n \"n - 1] (n being the vColumn cardinality). Returns -------\",\n \"after the comma. Returns ------- vDataFrame self.parent See Also --------\",\n \"\\\"\\\", stddev ) else: final_transformation = [ ( \\\"({} -\",\n \"number raised to the power of another number round :\",\n \"\\\"x\\\"), ) ) else: for k in range(max_floor): self.transformations +=\",\n \"model.drop() raise # ---# def describe( self, method: str =\",\n \"See Also -------- vDataFrame.add_copy : Creates a copy of the\",\n \"\\\", \\\".join(all_new_features) ) + \\\".\\\" ) return self.parent one_hot_encode =\",\n \"if by == []: if fun == \\\"AVG\\\": val =\",\n \"vColumn bar width. Parameters ---------- method: str, optional Method to\",\n \"Dictionary of the Random Forest model parameters used to compute\",\n \"data. method: str, optional The method to use to aggregate\",\n \"dropping the current vColumn and creating a copy with the\",\n \"= 0.25) AS Q1, APPROXIMATE_PERCENTILE({} USING PARAMETERS percentile = 0.75)\",\n \"numcol = self.parent.format_colnames(numcol) assert self.parent[numcol].category() in (\\\"float\\\", \\\"int\\\"), TypeError( \\\"The\",\n \"columns = [self.alias, by] else: columns = [self.alias] if of:\",\n \"count : Number of elements. density : Percentage of the\",\n \"= \\\"COALESCE({}, {})\\\".format(\\\"{}\\\", expr) elif method == \\\"0ifnull\\\": new_column =\",\n \"OR CONDITIONS OF ANY KIND, either express or implied. #\",\n \"rp] query = \\\"WITH vdf_table AS (SELECT * FROM {})\",\n \"elements in the vColumn with a user-specified rule. Parameters ----------\",\n \"LIMIT {}\\\".format(limit) else: limit = \\\"\\\" query = \\\"(SELECT {}\",\n \"Gaussian distribution to define the outliers. After normalizing the data\",\n \"= \\\"Can not normalize {} using a Z-Score - The\",\n \"END)\\\".format( bin_spatial_to_str(self.category()), \\\", \\\".join( [ \\\"'{}'\\\".format(str(elem).replace(\\\"'\\\", \\\"''\\\")) for elem in\",\n \"be generated. include_lowest: bool, optional If set to True, the\",\n \"of the following: date / int / float / text\",\n \"[\\\"mode\\\", \\\"0ifnull\\\"]: max_floor = 0 all_partition = by if method\",\n \"= 0.75) AS Q3, MAX({}) AS max FROM {}\\\".format( self.alias,\",\n \"drop(tmp_view_name, method=\\\"view\\\") self.parent.to_db(tmp_view_name) from verticapy.learn.ensemble import ( RandomForestClassifier, RandomForestRegressor, )\",\n \"Random Forest with 20 trees and a maximum depth of\",\n \"self.alias, y, y, query, ) query = \\\"SELECT {}, ord,\",\n \"tail.offset = offset tail.dtype[self.alias] = self.ctype() tail.name = self.alias return\",\n \"utilities.tablesample. See Also -------- vDataFrame.analytic : Adds a new vColumn\",\n \"/ date, optional Input End Date. For example, time =\",\n \") # ---# def str_replace(self, to_replace: str, value: str =\",\n \"), \\\"apply_test_feature\\\", ) except: ctype = get_data_types( \\\"SELECT {} AS\",\n \"if n == 0: nullifzero = 0 cmin, cmax =\",\n \"# |____/ / / # _____________ / / # \\\\\",\n \"Returns the head of the vColumn. \\\"\\\"\\\" return self.iloc(limit=limit, offset=-1)\",\n \"val: list, *args): \\\"\\\"\\\" --------------------------------------------------------------------------- Looks if some specific records\",\n \"See Also -------- vDataFrame.outliers : Computes the vDataFrame Global Outliers.\",\n \"'of'. max : Maximum of the vColumn 'of'. sum :\",\n \"ISOWEEK / ISOYEAR / MICROSECONDS / MILLENNIUM / MILLISECONDS /\",\n \"the mean encoding of a response. \\\"\\\"\\\" check_types( [ (\\\"prefix\\\",\",\n \"is set to 'smart'. return_enum_trans: bool, optional Returns the transformation\",\n \"density unique : cardinality (count distinct) var : variance Other\",\n \"optional parameter to pass to the geopandas plot function. For\",\n \"name: str): \\\"\\\"\\\" --------------------------------------------------------------------------- Adds a copy vColumn to the\",\n \") return executeSQL( query=query, title=\\\"Getting the vColumn element.\\\", method=\\\"fetchfirstelem\\\", )\",\n \"and built-in analytics and machine learning features. It supports the\",\n \": number of non-missing elements cvar : conditional value at\",\n \"# # ---# class vColumn(str_sql): \\\"\\\"\\\" --------------------------------------------------------------------------- Python object which\",\n \"{} \\\".format(\\\"{}\\\", lower, lower) if (isinstance(lower, (float, int))) else \\\"\\\"\",\n \"exponential function floor : value down to the next whole\",\n \"of one of the dummies ({name}).\\\\n\\\" \\\"It can be the\",\n \"Time Series of the vColumn. Parameters ---------- ts: str TS\",\n \"Step Plot. ax: Matplotlib axes object, optional The axes to\",\n \"\\\"start_date\\\", start_date, [str, datetime.datetime, datetime.date, int, float], ), ( \\\"end_date\\\",\",\n \"step: int): \\\"\\\"\\\" --------------------------------------------------------------------------- Slices the vColumn. The vColumn will\",\n \"pat, [str])]) return self.apply( func=\\\"REGEXP_COUNT({}, '{}')\\\".format(\\\"{}\\\", pat.replace(\\\"'\\\", \\\"''\\\")) ) #\",\n \"to the following: (function, type, category) parent: vDataFrame, optional Parent\",\n \"as e: raise ConversionError( \\\"{}\\\\nThe vColumn {} can not be\",\n \"(1.0 / 3.0), 1e-99) if method.lower() == \\\"sturges\\\": best_h =\",\n \"regular expression is in each of the vColumn records. vDataFrame[].extract\",\n \"] text_info += \\\"\\\\t{} => {}\\\".format(distinct_elements[k], k) expr = \\\",\",\n \"= self.aggregate([\\\"count\\\", \\\"min\\\", \\\"max\\\"]) index = result.values[\\\"index\\\"] result = result.values[self.alias]\",\n \"= 10): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns the n smallest elements in\",\n \"str, optional The vColumn to use to compute the aggregation.\",\n \"FROM (SELECT split_value, MAX(weighted_information_gain) FROM ({}) VERTICAPY_SUBTABLE WHERE split_value IS\",\n \"\\\"or simply because of ambiguous columns naming.\\\\nBy changing one of\",\n \"Number representing the outliers threshold. Values lesser than quantile(alpha) or\",\n \"was \\\" self.parent.__add_to_history__( \\\"[Get Dummies]: One hot encoder was applied\",\n \"int/tuple, optional Maximum number of distinct elements for vColumns 1\",\n \"all_partition: if len(self.parent[elem].transformations) > max_floor: max_floor = len(self.parent[elem].transformations) max_floor -=\",\n \"method in (\\\"mean\\\", \\\"median\\\") or isinstance(val, float): category, ctype =\",\n \"the func 'x -> {}' to '{}'\\\".format( e, func.replace(\\\"{}\\\", \\\"x\\\"),\",\n \"the vColumn type is date like). The vColumn will be\",\n \"category will be one of the following: date / int\",\n \"{}{} FROM {}{} OFFSET {} LIMIT 1\\\".format( self.alias, cast, self.parent.__genSQL__(),\",\n \"optional List of the vColumns to use to sort the\",\n \"(\\\"nbins\\\", nbins, [int, float]), ] ) if of: self.parent.are_namecols_in(of) of\",\n \": Computes the vDataFrame input aggregations. \\\"\\\"\\\" return self.aggregate([\\\"aad\\\"]).values[self.alias][0] #\",\n \"difference between the max and the min sem : standard\",\n \": Slices the vColumn using a time series rule. \\\"\\\"\\\"\",\n \"\\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using 'var' (Variance). Returns -------\",\n \"Also -------- vDataFrame[].drop_outliers : Drops outliers in the vColumn. vDataFrame.outliers\",\n \"may not use this file except in compliance with the\",\n \"CENTURY / DAY / DECADE / DOQ / DOW /\",\n \"= self.parent.format_colnames(y) assert self.parent[y].nunique() == 2, TypeError( \\\"vColumn {} must\",\n \"vColumn outliers. mean : Replaces the upper and lower outliers\",\n \"= [cat_priority] check_types( [ (\\\"by\\\", by, [str]), (\\\"max_cardinality\\\", max_cardinality, [int,\",\n \"method. Parameters ---------- method: str, optional The method to use\",\n \"Returns ------- vDataFrame self.parent See Also -------- vDataFrame.eval : Evaluates\",\n \"\\\"mean\\\", \\\"avg\\\", \\\"median\\\", \\\"ffill\\\", \\\"pad\\\", \\\"bfill\\\", \\\"backfill\\\", ], ), (\\\"expr\\\",\",\n \"return \\\"({} - {}) / {}({})\\\".format( self.alias, avg, \\\"NULLIFZERO\\\" if\",\n \"\\\".format(\\\"{}\\\", lower, lower) if (isinstance(lower, (float, int))) else \\\"\\\" )\",\n \"\\\"max\\\", ] if method != \\\"cat_stats\\\": values = { \\\"index\\\":\",\n \"pat: str): \\\"\\\"\\\" --------------------------------------------------------------------------- Verifies if the regular expression is\",\n \"simple: instead of moving # data around for processing, VerticaPy\",\n \"\\\"\\\"\\\" return self.ctype().lower() in (\\\"bool\\\", \\\"boolean\\\") # ---# def isdate(self):\",\n \"* result[\\\"std\\\"][0] + result[\\\"avg\\\"][0], ) else: query = \\\"SELECT PERCENTILE_CONT({})\",\n \"can drastically decrease. Returns ------- float/str median See Also --------\",\n \"response_cat == [0, 1], TypeError( \\\"vColumn {} must be binary\",\n \"values. auto : Mean for the numerical and Mode for\",\n \"{}, AVG({}), STDDEV({}) FROM {} GROUP BY {}\\\".format( by[0], self.alias,\",\n \"response. \\\"\\\"\\\" import verticapy.stats as st return self.apply(func=st.decode(str_sql(\\\"{}\\\"), *argv)) #\",\n \"conditional value at risk dtype : vColumn type iqr :\",\n \"str Response vColumn. Returns ------- vDataFrame self.parent See Also --------\",\n \"min) by: list, optional vColumns used in the partition. return_trans:\",\n \"(\\\"ffill\\\", \\\"pad\\\")) else \\\" DESC\\\" partition_by = ( \\\"PARTITION BY\",\n \"Maximum number of nbins used for the discretization (must be\",\n \"self.parent.__genSQL__(), self.alias, where, ) result = executeSQL( query=query, title=\\\"Computing the\",\n \"(SELECT {}, ROW_NUMBER() OVER (ORDER BY {}) AS _verticapy_row_nb_ FROM\",\n \"self.alias), self.alias, self.parent.__genSQL__(), self.alias, self.alias, self.alias, ) else: query =\",\n \"will be filtered. ax: Matplotlib axes object, optional The axes\",\n \"part of the vColumn. \\\"\\\"\\\" return self.iloc(limit=limit) # ---# def\",\n \"= (self.max() - self.min()) * 1.01 / nbins if h\",\n \"Maximum number of points to use to evaluate the approximate\",\n \"number of bins will be computed. h: float, optional Interval\",\n \"(nullifzero) else \\\"\\\", cmax, cmin, ) else: final_transformation = [\",\n \"* from verticapy.errors import * ## # # __ __\",\n \"self.parent.are_namecols_in(by) by = self.parent.format_colnames(by) columns = [self.alias, by] else: columns\",\n \"the current axes. ax: Matplotlib axes object, optional The axes\",\n \"of the vColumn based on an aggregation. \\\"\\\"\\\" if isinstance(pie_type,\",\n \"chart. rose : Rose chart. It can also be a\",\n \"title = \\\"Reads {}.\\\".format(self.alias) tail = to_tablesample( \\\"SELECT {} AS\",\n \"Q1, APPROXIMATE_PERCENTILE({} USING PARAMETERS percentile = 0.75) AS Q3, MAX({})\",\n \"True, the lowest element of the list will be included.\",\n \"by an input value. \\\"\\\"\\\" check_types([(\\\"start\\\", start, [int, float]), (\\\"step\\\",\",\n \"categorical aggregations during the computation. cat_stats : Computes statistics of\",\n \"ORDER BY COUNT(*) DESC LIMIT {1})\\\"\\\"\\\".format( self.alias, max_cardinality ) if\",\n \"!= 0, Exception( \\\"Not enough values to compute the Equal\",\n \"\\\"{}, {}\\\".format( \\\"'{}'\\\".format(str(elem[0]).replace(\\\"'\\\", \\\"''\\\")) if elem[0] != None else \\\"NULL\\\",\",\n \"Warning) return self elif n == 1: try: result =\",\n \"donut, rose, ax=None, **style_kwds, ) # ---# def plot( self,\",\n \"\\\"\\\"\\\" return self.iloc(limit=limit, offset=-1) # ---# def topk(self, k: int\",\n \"result index = [ \\\"unique\\\", \\\"count\\\", \\\"mean\\\", \\\"std\\\", \\\"min\\\", \\\"approx_25%\\\",\",\n \"will not be considered during the computation. n: int, optional\",\n \"size unit. For example, it can be 'minute' 'hour'... start:\",\n \"dtype, [str])]) try: query = \\\"SELECT {}::{} AS {} FROM\",\n \"set to 'cat_stats'. Returns ------- tablesample An object containing the\",\n \"COUNT({1}) / {2} AS percent, AVG({3}{4}) AS mean, STDDEV({3}{4}) AS\",\n \"[\\\"{}, {}\\\".format(elem[0], elem[1]) for elem in result] ), ) executeSQL(\",\n \"GROUP BY {0} ORDER BY COUNT(*)\\\" \\\" DESC OFFSET {1})\",\n \"0 and 1 (1 meaning global outlier). \\\"\\\"\\\" if isinstance(method,\",\n \"bool = True, alpha: float = 0.05, ): \\\"\\\"\\\" ---------------------------------------------------------------------------\",\n \"PARAMETERS percentile = 0.9) AS 'approx_90%', MAX({3}{4}) AS max FROM\",\n \"the input vColumn. \\\"\\\"\\\" return self.apply(func=\\\"ABS({})\\\") # ---# def add(self,\",\n \"assert name.replace('\\\"', \\\"\\\"), EmptyParameter( \\\"The parameter 'name' must not be\",\n \"Returns the nth most occurent element. Parameters ---------- dropna: bool,\",\n \"Python library with scikit-like functionality for conducting # data science\",\n \"self.alias.replace('\\\"', \\\"\\\"), func.replace(\\\"{}\\\", \\\"x\\\"), ) ) return self.parent except Exception\",\n \"for each vColumn category. In this case, the parameter 'numcol'\",\n \"be a vDataFrame column if the method is 'cat_stats'\\\" )\",\n \"= -1, k: int = 6, new_category: str = \\\"Others\\\",\",\n \"setattr(self.parent, name[1:-1], new_vColumn) self.parent._VERTICAPY_VARIABLES_[\\\"columns\\\"] += [name] self.parent.__add_to_history__( \\\"[Add Copy]: A\",\n \"uuid / undefined Returns ------- str vColumn category. See Also\",\n \"of an independent variable in relation to the dependent variable.\",\n \"else: avg, stddev = ( \\\"AVG({}) OVER (PARTITION BY {})\\\".format(\",\n \"result, } if ((is_date) and not (method == \\\"categorical\\\")) or\",\n \"|| (FLOOR({} / {}) * {} + {}{}) || ']'\\\".format(\",\n \"\\\"apply_test_feature\\\", ) category = get_category_from_vertica_type(ctype=ctype) all_cols, max_floor = self.parent.get_columns(), 0\",\n \"(\\\"max_cardinality\\\", max_cardinality, [int, float]), (\\\"nbins\\\", nbins, [int, float]), (\\\"h\\\", h,\",\n \"result. For more information, see utilities.tablesample. See Also -------- vDataFrame.aggregate\",\n \"'index', COUNT({1}) AS count, 100 * COUNT({1}) / {2} AS\",\n \"x: float): \\\"\\\"\\\" --------------------------------------------------------------------------- Divides the vColumn by the input\",\n \"avoid the creation of correlated features. use_numbers_as_suffix: bool, optional Uses\",\n \"Method to use to impute the missing values. auto :\",\n \"\\\"\\\", cmax, cmin, ) else: final_transformation = [ ( \\\"({}\",\n \"[str])]) return self.apply( func=\\\"REGEXP_COUNT({}, '{}') > 0\\\".format(\\\"{}\\\", pat.replace(\\\"'\\\", \\\"''\\\")) )\",\n \"else \\\"END\\\" return self.apply( func=\\\"TIME_SLICE({}, {}, '{}', '{}')\\\".format( \\\"{}\\\", length,\",\n \"1) Returns ------- tablesample An object containing the result. For\",\n \") warnings.warn(warning_message, Warning) return self elif n == 1: try:\",\n \"can write the following list: [\\\"Fouad\\\", \\\"Badr\\\"] Returns ------- vDataFrame\",\n \"check_types([(\\\"name\\\", name, [str])]) name = quote_ident(name.replace('\\\"', \\\"_\\\")) assert name.replace('\\\"', \\\"\\\"),\",\n \"------- bool True if the vColumn is boolean. See Also\",\n \"self.parent.shape()[0] ) for elem in sauv: if \\\"top\\\" in elem:\",\n \"by the input element. Parameters ---------- x: float Input number.\",\n \": number raised to the power of another number round\",\n \"\\\"pow\\\", \\\"round\\\", \\\"sign\\\", \\\"sin\\\", \\\"sinh\\\", \\\"sqrt\\\", \\\"tan\\\", \\\"tanh\\\", ], ),\",\n \"len(by) if self.isbool(): warning_message = \\\"Normalize doesn't work on booleans\\\".format(self.alias)\",\n \"first element (Constant Interpolation). mean : Average. median : median.\",\n \"(\\\"x\\\", x, [int, float]), ] ) if func not in\",\n \"See Also -------- vDataFrame.plot : Draws the time series. \\\"\\\"\\\"\",\n \"memory_usage(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns the vColumn memory usage. Returns -------\",\n \"% len(colors)]} ax = self.parent.search( \\\"{} = '{}'\\\".format(self.parent[by].alias, column) )[self.alias].density(\",\n \"kwargs: query = \\\"SELECT {} AS {} FROM {} WHERE\",\n \"user-defined encoding. Parameters ---------- argv: object Any amount of expressions.\",\n \"method=\\\"numerical\\\", columns=[self.alias], unique=False ) .transpose() .values[self.alias] ) result = [distinct_count]\",\n \"-------- vDataFrame[].apply : Applies a function to the vColumn. \\\"\\\"\\\"\",\n \"{} || ';' || (FLOOR({} / {}) * {} +\",\n \"prefix.replace('\\\"', \\\"_\\\") + prefix_sep.replace('\\\"', \\\"_\\\") ) n = 1 if\",\n \"= product # ---# def quantile(self, x: float, approx: bool\",\n \"the absolute value function to the input vColumn. Returns -------\",\n \"[ (\\\"ts\\\", ts, [str]), (\\\"q\\\", q, [tuple]), ( \\\"start_date\\\", start_date,\",\n \"response, ParameterError( \\\"Parameter 'response' can not be empty in case\",\n \"and method in (\\\"same_width\\\", \\\"auto\\\"): if not (h) or h\",\n \"an aggregation. \\\"\\\"\\\" if isinstance(pie_type, str): pie_type = pie_type.lower() check_types(\",\n \"greater or equal to 2.\\\" ) assert len(breaks) == len(labels)\",\n \") else: raise TypeError(\\\"The vColumn must be numerical for Normalization\\\")\",\n \"AS {} FROM {} WHERE {} IS NOT NULL LIMIT\",\n \"Also -------- vDataFrame.outliers : Computes the vDataFrame Global Outliers. \\\"\\\"\\\"\",\n \"- {}) / ({})\\\".format(self.alias, med, mad) else: final_transformation = [\",\n \"- avg) / std robust_zscore : Normalization using the Robust\",\n \"set to 'smart'. return_enum_trans: bool, optional Returns the transformation instead\",\n \"mean_alpha = \\\"NULL\\\" self.apply( func=\\\"(CASE WHEN {} < {} THEN\",\n \"step: bool, optional If set to True, draw a Step\",\n \"the vColumn DB type. Returns ------- str vColumn DB type.\",\n \"( RandomForestClassifier, RandomForestRegressor, ) drop(tmp_model_name, method=\\\"model\\\") if self.parent[response].category() == \\\"float\\\":\",\n \"self.parent.format_colnames(by) if method == \\\"auto\\\": method = \\\"mean\\\" if (self.isnum()\",\n \"greater than quantile(1-alpha) will be dropped. Returns ------- vDataFrame self.parent\",\n \": median min : minimum mode : most occurent element\",\n \"self.parent.__genSQL__(), self.alias, self.alias, self.alias, ) else: query = \\\"SELECT {}\",\n \"\\\\____ \\\\ \\\\ \\\\/\\\\ \\\\ \\\\ \\\\ \\\\____ \\\\ \\\\\",\n \"bool = True, alpha: float = 0.05 ): \\\"\\\"\\\" ---------------------------------------------------------------------------\",\n \"---# def skewness(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using 'skewness'.\",\n \"/ ISOYEAR / MICROSECONDS / MILLENNIUM / MILLISECONDS / MINUTE\",\n \"= [distinct_count, self.count()] + [item[1] for item in query_result] index\",\n \") ) return self.parent # ---# def fillna( self, val=None,\",\n \"+= final_transformation sauv = {} for elem in self.catalog: sauv[elem]\",\n \"(\\\"response\\\", response, [str]), (\\\"nbins\\\", nbins, [int, float]), ( \\\"method\\\", method,\",\n \"parameter is equal to 0, an optimised interval will be\",\n \"= 5, offset: int = 0): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns a\",\n \"1, ParameterError(\\\"Parameter 'n' must be greater or equal to 1\\\")\",\n \"> 1 else \\\" was \\\" if verticapy.options[\\\"print_info\\\"]: print(\\\"{} element{}filled.\\\".format(total,\",\n \") setattr(self.parent, name, new_vColumn) setattr(self.parent, name.replace('\\\"', \\\"\\\"), new_vColumn) self.parent._VERTICAPY_VARIABLES_[\\\"columns\\\"] +=\",\n \"\\\"({} - {}) / {}({})\\\".format( \\\"{}\\\", avg, \\\"NULLIFZERO\\\" if (nullifzero)\",\n \"bandwidth: float, optional The bandwidth of the kernel. kernel: str,\",\n \"= gen_tmp_name(schema=schema, name=\\\"kde\\\") if isinstance(xlim, (tuple, list)): xlim_tmp = [xlim]\",\n \"\\\"'{}', {}\\\".format(str(distinct_elements[k]).replace(\\\"'\\\", \\\"''\\\"), k) ] text_info += \\\"\\\\t{} => {}\\\".format(distinct_elements[k],\",\n \"a function to the input vColumn. \\\"\\\"\\\" return self.apply(func=\\\"ABS({})\\\") #\",\n \"self.alias ) executeSQL(query, title=\\\"Testing the Type casting.\\\") self.transformations += [\",\n \"ax: Matplotlib axes object, optional The axes to plot on.\",\n \"input type. Parameters ---------- dtype: str New type. Returns -------\",\n \": Computes the vDataFrame input aggregations. \\\"\\\"\\\" return self.aggregate([\\\"variance\\\"]).values[self.alias][0] variance\",\n \"You can write the following list: [\\\"Fouad\\\", \\\"Badr\\\"] Returns -------\",\n \"start, [bool]), ] ) start_or_end = \\\"START\\\" if (start) else\",\n \"the offset. For example, if n = 1 then this\",\n \"alias: str, transformations: list = [], parent=None, catalog: dict =\",\n \"USING PARAMETERS percentile = 0.75) AS 'approx_75%', APPROXIMATE_PERCENTILE ({3}{4} USING\",\n \"by = [by] if isinstance(order_by, str): order_by = [order_by] check_types(\",\n \"Returns ------- float vColumn memory usage (byte) See Also --------\",\n \"more information, see utilities.tablesample. See Also -------- vDataFrame[].describe : Computes\",\n \"Returns True if the vColumn is numerical. \\\"\\\"\\\" return self.ctype().lower()\",\n \"10) return self.parent[columns].to_geopandas(self.alias).plot(*args, **kwargs) # ---# def get_dummies( self, prefix:\",\n \"{} FROM (SELECT {}, ROW_NUMBER() OVER (ORDER BY {}) AS\",\n \"verticapy.learn.ensemble import ( RandomForestClassifier, RandomForestRegressor, ) drop(tmp_model_name, method=\\\"model\\\") if self.parent[response].category()\",\n \"None: pass elif math.isnan(result[i][2]): result[i][2] = None avg = \\\"DECODE({},\",\n \"= [elem[0] for elem in result] elif self.isnum() and method\",\n \") except: avg, stddev = ( \\\"AVG({}) OVER (PARTITION BY\",\n \"\\\"auto\\\"): \\\"\\\"\\\" --------------------------------------------------------------------------- Computes the optimal vColumn bar width. Parameters\",\n \"the vColumn. method: dict, optional Method to use to impute\",\n \"name.replace('\\\"', \\\"\\\"), new_vColumn) self.parent._VERTICAPY_VARIABLES_[\\\"columns\\\"] += [name] all_new_features += [name] conj\",\n \") result = executeSQL( query, title=\\\"Different aggregations to compute the\",\n \"OVER (PARTITION BY {})\\\".format(response, \\\"{}\\\"), \\\"int\\\", \\\"float\\\") ] self.parent.__update_catalog__(erase=True, columns=[self.alias])\",\n \"optional If the function has two arguments (example, power or\",\n \"MAX({3}{4}) AS max FROM vdf_table\\\"\\\"\\\".format( category, self.alias, self.parent.shape()[0], numcol, cast,\",\n \"if self.isdate(): return self.apply(func=\\\"TIMESTAMPADD(SECOND, -({}), {})\\\".format(x, \\\"{}\\\")) else: return self.apply(func=\\\"{}\",\n \"[top]} ) return top # ---# def mul(self, x: float):\",\n \"h, ax=ax, **style_kwds) # ---# def boxplot( self, by: str\",\n \"method is set to 'smart'. return_enum_trans: bool, optional Returns the\",\n \"= int(sauv[\\\"count\\\"]) + total self.catalog[\\\"percent\\\"] = ( 100 * (int(sauv[\\\"count\\\"])\",\n \"optional List of the different categories to consider when drawing\",\n \"expected store usage. See Also -------- vDataFrame.expected_store_usage : Returns the\",\n \"the vColumn. \\\"\\\"\\\" check_types([(\\\"pat\\\", pat, [str])]) return self.apply( func=\\\"REGEXP_COUNT({}, '{}')\\\".format(\\\"{}\\\",\",\n \"], ), (\\\"x\\\", x, [int, float]), ] ) if func\",\n \"Z-Score - The Standard Deviation is null !\\\".format( self.alias )\",\n \"empty.\\\" ) conditions, column = [], self.alias for idx in\",\n \"GROUP BY {0} ORDER BY COUNT(*) DESC LIMIT {1})\\\"\\\"\\\".format( self.alias,\",\n \"---------- field: str The field to extract. It must be\",\n \"2, ParameterError( \\\"Parameter 'nbins' must be greater or equals to\",\n \"val: int/float/str, optional Value to use to impute the vColumn.\",\n \"statistics of {}.\\\".format(self.alias), method=\\\"fetchall\\\", ) result = [distinct_count, self.count()] +\",\n \"1 self.parent.__add_to_history__( \\\"[Normalize]: The vColumn '{}' was normalized with the\",\n \"the input method. Parameters ---------- method: str, optional The method\",\n \"str = \\\"\\\", bandwidth: float = 1.0, kernel: str =\",\n \"to compute the Equal Frequency discretization\\\" ) total, query, nth_elems\",\n \"\\\", \\\".join(by) ), \\\"MIN({}) OVER (PARTITION BY {})\\\".format( self.alias, \\\",\",\n \") except: pass max_floor -= len(self.transformations) if copy_name: self.add_copy(name=copy_name) for\",\n \"to_tablesample(query, title=title) # ---# def normalize( self, method: str =\",\n \"+= [name] self.parent.__add_to_history__( \\\"[Add Copy]: A copy of the vColumn\",\n \"---# def fill_outliers( self, method: str = \\\"winsorize\\\", threshold: float\",\n \"one of the dummies ({name}).\\\\n\\\" \\\"It can be the result\",\n \"close_l = \\\"<=\\\", \\\"[\\\" elif idx == 0: op1, close_l\",\n \"check_types( [ (\\\"method\\\", method, [\\\"winsorize\\\", \\\"null\\\", \\\"mean\\\"]), (\\\"alpha\\\", alpha, [int,\",\n \"# ---# def __nonzero__(self): return self.count() > 0 # ---#\",\n \"[(\\\"{}\\\", self.ctype(), self.category())] self.transformations += final_transformation sauv = {} for\",\n \"an optimized h will be computed. pie_type: str, optional The\",\n \"= [], ): \\\"\\\"\\\" --------------------------------------------------------------------------- Fills missing elements in the\",\n \"\\\"\\\"\\\" check_types( [ (\\\"method\\\", method, [\\\"auto\\\", \\\"numerical\\\", \\\"categorical\\\", \\\"cat_stats\\\"]), (\\\"max_cardinality\\\",\",\n \"different transformations. \\\"\\\"\\\" # # Special Methods # # ---#\",\n \"return_trans: return \\\"({} - {}) / {}({} - {})\\\".format( self.alias,\",\n \"number of nbins will be computed. h: float, optional Interval\",\n \"= self.parent.format_colnames(by) if method == \\\"auto\\\": method = \\\"mean\\\" if\",\n \"the Information Value (IV) Table. \\\"\\\"\\\" check_types([(\\\"y\\\", y, [str]), (\\\"nbins\\\",\",\n \"using 'mad' (median absolute deviation). Returns ------- float mad See\",\n \": Applies a function to the vColumn. \\\"\\\"\\\" check_types( [\",\n \"look like: even: CASE ... WHEN vColumn = argv[2 *\",\n \"computation. Returns ------- tablesample An object containing the result. For\",\n \"if total > 1 else \\\" was \\\" if verticapy.options[\\\"print_info\\\"]:\",\n \"def sum(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using 'sum'. Returns\",\n \"category, ctype = \\\"int\\\", \\\"bool\\\" else: category, ctype = self.category(),\",\n \"vColumn. vDataFrame[].str_slice : Slices the vColumn. \\\"\\\"\\\" check_types([(\\\"to_replace\\\", to_replace, [str]),\",\n \"elem in order_by] + by) by = self.parent.format_colnames(by) if method\",\n \"\\\"\\\"\\\" --------------------------------------------------------------------------- Draws the vColumn Density Plot. Parameters ---------- by:\",\n \"= \\\"\\\" ): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using multiple\",\n \"look at the final transformation. Returns ------- vDataFrame self.parent See\",\n \"__ `\\\\ / / # | \\\\/ / / /\",\n \"check_types([(\\\"x\\\", x, [int, float])]) if self.isdate(): return self.apply(func=\\\"TIMESTAMPADD(SECOND, -({}), {})\\\".format(x,\",\n \"remainder of a division operation pow : number raised to\",\n \"Iterable)): val = [val] val += list(args) check_types([(\\\"val\\\", val, [list])])\",\n \"ts, [str]), (\\\"by\\\", by, [str]), (\\\"start_date\\\", start_date, [str, datetime.datetime, datetime.date]),\",\n \"closed on the right. Returns ------- vDataFrame self.parent See Also\",\n \"new_vColumn = vColumn( name, parent=self.parent, transformations=transformations, catalog={ \\\"min\\\": 0, \\\"max\\\":\",\n \"done.\\\") return self.parent # ---# def median( self, approx: bool\",\n \"plot_median: bool, optional If set to True, the Median will\",\n \"than quantile(1-alpha) will be dropped. Returns ------- vDataFrame self.parent See\",\n \"self.apply( func=\\\"REGEXP_SUBSTR({}, '{}')\\\".format(\\\"{}\\\", pat.replace(\\\"'\\\", \\\"''\\\")) ) # ---# def str_replace(self,\",\n \"\\\"COALESCE({}, LAST_VALUE({} IGNORE NULLS) OVER ({} ORDER BY {}))\\\".format( \\\"{}\\\",\",\n \"= True, alpha: float = 0.05, ): \\\"\\\"\\\" --------------------------------------------------------------------------- Fills\",\n \"range_plot( self, ts: str, q: tuple = (0.25, 0.75), start_date:\",\n \"the input vColumns. vDataFrame.applymap : Applies a function to all\",\n \"Python object which that stores all user transformations. If the\",\n \"in writing, software # distributed under the License is distributed\",\n \"governing permissions and # limitations under the License. # #\",\n \"+= [ f\\\"'{first_elem}' {op1} {column} AND {column} {op2} '{second_elem}' THEN\",\n \"Matplotlib axes object, optional The axes to plot on. **style_kwds\",\n \"== \\\"auto\\\": method = \\\"mean\\\" if (self.isnum() and self.nunique(True) >\",\n \"= sturges elif method.lower() in (\\\"freedman_diaconis\\\", \\\"fd\\\"): best_h = fd\",\n \"to the input vColumn. \\\"\\\"\\\" check_types([(\\\"x\\\", x, [int, float])]) return\",\n \"by an offset and a limit). Parameters ---------- limit: int,\",\n \"self, prefix: str = \\\"\\\", prefix_sep: str = \\\"_\\\", drop_first:\",\n \"not (method == \\\"categorical\\\"): result = self.aggregate([\\\"count\\\", \\\"min\\\", \\\"max\\\"]) index\",\n \"and # limitations under the License. # # |_ |~)\",\n \"1.4826 elif method == \\\"zscore\\\": self.catalog[\\\"mean\\\"] = 0 self.catalog[\\\"std\\\"] =\",\n \") tmp_query += ( \\\" WHERE {} IS NULL\\\".format(self.alias) if\",\n \"query_result = executeSQL( query=query, title=\\\"Computing the descriptive statistics of {}.\\\".format(self.alias),\",\n \"mad) else: final_transformation = [ ( \\\"({} - {}) /\",\n \"\\\"zscore\\\": self.catalog[elem] = (sauv[elem] - sauv[\\\"mean\\\"]) / sauv[ \\\"std\\\" ]\",\n \"= True): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using 'unique' (cardinality).\",\n \"{})\\\".format(self.alias, p_alpha, p_1_alpha) ) return self.parent # ---# def dropna(self):\",\n \"parameter is very useful for testing to be able to\",\n \"the vDataFrame input aggregations. \\\"\\\"\\\" return self.quantile(0.5, approx=approx) # ---#\",\n \"pat: str): \\\"\\\"\\\" --------------------------------------------------------------------------- Extracts the regular expression in each\",\n \"--------------------------------------------------------------------------- Computes the Information Value (IV) / Weight Of Evidence\",\n \"{}, {} FROM {} LIMIT 1\\\".format( avg, stddev, self.parent.__genSQL__() ),\",\n \"\\\"PARTITION BY {}\\\".format( \\\", \\\".join([quote_ident(column) for column in by]) )\",\n \"else: new_column = \\\"COALESCE({}, {}({}) OVER (PARTITION BY {}))\\\".format( \\\"{}\\\",\",\n \"TS field from the vColumn (only if the vColumn type\",\n \"base 10 logarithm mod : remainder of a division operation\",\n \"= \\\"Reads {} {} smallest elements.\\\".format(n, self.alias) return to_tablesample(query, title=title)\",\n \"= 0.1) AS 'approx_10%', APPROXIMATE_PERCENTILE ({3}{4} USING PARAMETERS percentile =\",\n \"Computes the vDataFrame input aggregations. \\\"\\\"\\\" return self.aggregate([\\\"kurtosis\\\"]).values[self.alias][0] kurt =\",\n \"---------- add_history: bool, optional If set to True, the information\",\n \"Number of elements to skip. Returns ------- tablesample An object\",\n \"Parameters ---------- method: str, optional Method to use to normalize.\",\n \"= \\\"\\\", method: str = \\\"density\\\", of: str = \\\"\\\",\",\n \"( -threshold * result[\\\"std\\\"][0] + result[\\\"avg\\\"][0], threshold * result[\\\"std\\\"][0] +\",\n \"elements and their distributions as percents. Parameters ---------- k: int,\",\n \"new_column = \\\"COALESCE({}, {})\\\".format(\\\"{}\\\", expr) elif method == \\\"0ifnull\\\": new_column\",\n \"] else: warning_message = \\\"Can not normalize {} using a\",\n \"AS _verticapy_cnt_ FROM {}{}GROUP BY {} ORDER BY _verticapy_cnt_ DESC\",\n \"datetime.date] = \\\"\\\", area: bool = False, step: bool =\",\n \"the vColumn expected store usage (unit: b). Returns ------- int\",\n \"float/str minimum See Also -------- vDataFrame.aggregate : Computes the vDataFrame\",\n \"assert self.parent[numcol].category() in (\\\"float\\\", \\\"int\\\"), TypeError( \\\"The column 'numcol' must\",\n \"count, vColumn_min, vColumn_025, vColumn_075, vColumn_max = ( result[0], result[3], result[4],\",\n \"if the parameter is empty or invalid. max_cardinality: int/tuple, optional\",\n \"elements q% : q quantile (ex: 50% for the median)\",\n \"']'\\\".format( \\\"{}\\\", h, h, \\\"{}\\\", h, h, h, floor_end ),\",\n \"int(nbins): nth_elems += [str(total)] total += nb where = \\\"WHERE\",\n \"{})\\\".format( self.parent.__genSQL__(), self.alias, self.alias, p_alpha, self.alias, self.alias, p_1_alpha, ) mean_alpha,\",\n \"vColumn with a user-specified rule. Parameters ---------- val: int/float/str, optional\",\n \"Returns ------- float/str median See Also -------- vDataFrame.aggregate : Computes\",\n \"vColumn records. vDataFrame[].str_count : Computes the number of matches for\",\n \"return self.parent # ---# def dropna(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Filters the\",\n \"), ) else: avg, stddev = ( \\\"AVG({}) OVER (PARTITION\",\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_() #\",\n \"(self.parent[by[0]].nunique() < 50): try: if fun == \\\"MEDIAN\\\": fun =\",\n \".transpose() .values[self.alias] ) count, vColumn_min, vColumn_025, vColumn_075, vColumn_max = (\",\n \"of 10. response: str, optional Response vColumn when method is\",\n \"\\\"SELECT {}, MIN({}), MAX({}) FROM {} GROUP BY {}\\\".format( by[0],\",\n \"an Area Plot. step: bool, optional If set to True,\",\n \"the dummies. prefix_sep: str, optional Prefix delimitor of the dummies.\",\n \"[bool]), (\\\"n\\\", n, [int, float])]) if n == 1: pre_comp\",\n \"bound quantile(1-alpha) if 'use_threshold' is set to False else the\",\n \"parent. catalog: dict, optional Catalog where each key corresponds to\",\n \"/ / # _____________ / / # \\\\ / /\",\n \"# http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or\",\n \"1) or (self.category() == \\\"float\\\"): trans = ( \\\"'[' ||\",\n \"index = [ \\\"unique\\\", \\\"count\\\", \\\"mean\\\", \\\"std\\\", \\\"min\\\", \\\"approx_25%\\\", \\\"approx_50%\\\",\",\n \"(SELECT AVG({}) FROM vdf_table WHERE {} > {})\\\".format( self.parent.__genSQL__(), self.alias,\",\n \"risk dtype : vColumn type iqr : interquartile range kurtosis\",\n \"statics of {} partitioned by {}.\\\".format( numcol, self.alias ) values\",\n \"{})\\\".format(func.upper(), \\\"{}\\\", x) return self.apply(func=expr) # ---# def astype(self, dtype:\",\n \"!= \\\"cat_stats\\\") or (numcol), ParameterError( \\\"The parameter 'numcol' must be\",\n \"[]: if fun == \\\"AVG\\\": val = self.avg() elif fun\",\n \"= \\\"\\\", plot_median: bool = False, ax=None, **style_kwds, ): \\\"\\\"\\\"\",\n \": List of the different transformations. \\\"\\\"\\\" # # Special\",\n \"See Also -------- vDataFrame.eval : Evaluates a customized expression. \\\"\\\"\\\"\",\n \"\\\"tanh\\\", ], ), (\\\"x\\\", x, [int, float]), ] ) if\",\n \"= \\\"auto\\\"): \\\"\\\"\\\" --------------------------------------------------------------------------- Computes the optimal vColumn bar width.\",\n \"= self.parent.format_colnames(ts) from verticapy.plot import range_curve_vdf return range_curve_vdf( self, ts,\",\n \"else \\\"NULL\\\", ) for elem in result if elem[1] !=\",\n \"= 0, ax=None, **style_kwds, ): \\\"\\\"\\\" --------------------------------------------------------------------------- Draws the bar\",\n \"# ---# def _repr_html_(self): return self.head(limit=verticapy.options[\\\"max_rows\\\"])._repr_html_() # ---# def __setattr__(self,\",\n \"\\\\ \\\\ \\\\-./\\\\ \\\\ \\\\ \\\\ \\\\-. \\\\ # \\\\\",\n \"Parameters ---------- val: int/float/str, optional Value to use to impute\",\n \"= xlim custom_lines = [] columns = self.parent[by].distinct() for idx,\",\n \"vColumn records by an input value. vDataFrame[].str_slice : Slices the\",\n \"/ undefined Returns ------- str vColumn category. See Also --------\",\n \"FROM ({}) VERTICAPY_SUBTABLE WHERE split_value IS NOT NULL GROUP BY\",\n \"'use_threshold' is set to False else the lower and upper\",\n \"the vColumn is numerical. \\\"\\\"\\\" return self.ctype().lower() in (\\\"bool\\\", \\\"boolean\\\")\",\n \"in (\\\"ffill\\\", \\\"pad\\\", \\\"bfill\\\", \\\"backfill\\\"): assert order_by, ParameterError( \\\"If the\",\n \") return vDataFrameSQL(query) elif isinstance(index, int): cast = \\\"::float\\\" if\",\n \"END Returns ------- vDataFrame self.parent See Also -------- vDataFrame.case_when :\",\n \"the vColumn. You can write the following list: [\\\"Fouad\\\", \\\"Badr\\\"]\",\n \"DESC OFFSET {1}) VERTICAPY_SUBTABLE) ORDER BY count DESC\\\" ).format(self.alias, max_cardinality\",\n \"method == \\\"robust_zscore\\\": self.catalog[elem] = (sauv[elem] - sauv[\\\"approx_50%\\\"]) / (\",\n \"data. h: float, optional Interval width if the vColumn is\",\n \"method, [str]), (\\\"of\\\", of, [str]), (\\\"max_cardinality\\\", max_cardinality, [int, float]), (\\\"h\\\",\",\n \"NOT NULL LIMIT 20\\\".format( self.alias, dtype, self.alias, self.parent.__genSQL__(), self.alias )\",\n \") conditions, column = [], self.alias for idx in range(len(breaks)\",\n \"not (labels), ParameterError( \\\"Length of parameter breaks must be equal\",\n \"vColumn with the One-Hot Encoding algorithm. Parameters ---------- prefix: str,\",\n \"be > 1) k: int, optional The integer k of\",\n \"len( self.transformations ) for k in range(max_floor): self.transformations += [(\\\"{}\\\",\",\n \"right, [bool]), ] ) assert self.isnum() or self.isdate(), TypeError( \\\"cut\",\n \"self.parent.__add_to_history__( \\\"[Discretize]: The vColumn {} was discretized.\\\".format(self.alias) ) return self.parent\",\n \": Jarque-Bera index mad : median absolute deviation max :\",\n \"instead of the vColumns categories. Returns ------- vDataFrame self.parent See\",\n \"1 if drop_first else 0 for k in range(len(distinct_elements) -\",\n \"FROM {} WHERE {} IS NOT NULL LIMIT 20\\\".format( self.alias,\",\n \"(by) else \\\"\\\" ) order_by_ts = \\\", \\\".join([quote_ident(column) + desc\",\n \"\\\"\\\"\\\" --------------------------------------------------------------------------- Draws the Geospatial object. Parameters ---------- *args /\",\n \"ambiguous columns naming.\\\\nBy changing one of \\\" \\\"the parameters ('prefix',\",\n \"\\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using 'avg' (Average). Returns -------\",\n \"optional Response vColumn when method is set to 'smart'. return_enum_trans:\",\n \"respective average. null : Replaces the outliers by the NULL\",\n \"to use to partition the data. bandwidth: float, optional The\",\n \"of: str = \\\"\\\", max_cardinality: int = 6, h: float\",\n \"< {} THEN {} WHEN {} > {} THEN {}\",\n \"the regular expression matches in each of the vColumn records\",\n \"# Unless required by applicable law or agreed to in\",\n \"be greater or equals to 2 in case of discretization\",\n \"1 elif method == \\\"minmax\\\": self.catalog[\\\"min\\\"] = 0 self.catalog[\\\"max\\\"] =\",\n \"= self.distinct() if distinct_elements not in ([0, 1], [1, 0])\",\n \"to partition the TS. start_date: str / date, optional Input\",\n \"of the vColumn. \\\"\\\"\\\" return self.iloc(limit=limit, offset=-1) # ---# def\",\n \"Union[int, tuple] = (6, 6), h: Union[int, float, tuple] =\",\n \"(\\\"h\\\", h, [int, float]), (\\\"response\\\", response, [str]), (\\\"nbins\\\", nbins, [int,\",\n \"\\\\ /\\\\ \\\\ /\\\\ \\\\/\\\\ \\\\ /\\\\ \\\"-./ \\\\ /\\\\\",\n \"the threshold it will be considered as an outlier. use_threshold:\",\n \"\\\"\\\"\\\" --------------------------------------------------------------------------- Returns the vColumn memory usage. Returns ------- float\",\n \"vColumn memory usage. Returns ------- float vColumn memory usage (byte)\",\n \"WHEN {} > {} THEN {} ELSE {} END)\\\".format( \\\"{}\\\",\",\n \"the vDataFrame history. Returns ------- vDataFrame self.parent See Also --------\",\n \"--------------------------------------------------------------------------- Aggregates the vColumn using 'product'. Returns ------- float product\",\n \"add_history, [bool])]) try: parent = self.parent force_columns = [ column\",\n \"optional Uses the threshold instead of the 'alpha' parameter. alpha:\",\n \"to be able to look at the final transformation. Returns\",\n \"= executeSQL( query=query, title=\\\"Computing the descriptive statistics of {}.\\\".format(self.alias), method=\\\"fetchall\\\",\",\n \"{} ORDER BY _verticapy_cnt_ DESC LIMIT {}) VERTICAPY_SUBTABLE ORDER BY\",\n \"for elem in order_by] + by) by = self.parent.format_colnames(by) if\",\n \"mean encoding\\\" ) max_floor = len(self.parent[response].transformations) - len( self.transformations )\",\n \"= val.replace(\\\"'\\\", \\\"''\\\") if val != None: new_column = \\\"COALESCE({},\",\n \"must be numerical to use a mean encoding\\\" ) max_floor\",\n \"regular expression in each record of the vColumn. vDataFrame[].str_replace :\",\n \"in (\\\"log\\\", \\\"mod\\\", \\\"pow\\\", \\\"round\\\"): expr = \\\"{}({})\\\".format(func.upper(), \\\"{}\\\") else:\",\n \"if the parameter 'by' is empty\\\\nIf you want to normalize\",\n \"(\\\"use_numbers_as_suffix\\\", use_numbers_as_suffix, [bool]), ] ) distinct_elements = self.distinct() if distinct_elements\",\n \"\\\\ \\\\_\\\\ \\\\ \\\\_\\\\\\\\\\\"\\\\_\\\\ # \\\\/_/ \\\\/_____/ \\\\/_____/ \\\\/_____/ \\\\/_____/\",\n \"\\\" \\\"issue.\\\" ) for k in range(len(distinct_elements) - n): name\",\n \"be equal to the length of parameter 'labels' + 1\",\n \"\\\\/\\\\ \\\\ /\\\\ \\\"-./ \\\\ /\\\\ \\\"-.\\\\ \\\\ # \\\\\",\n \"\\\"\\\"\\\" # # Special Methods # # ---# def __init__(\",\n \"entire data science life cycle, uses a ‘pipeline’ mechanism to\",\n \"--------------------------------------------------------------------------- Draws the vColumn Density Plot. Parameters ---------- by: str,\",\n \"bins. smart : Uses the Random Forest on a response\",\n \": Computes the vDataFrame input aggregations. \\\"\\\"\\\" return self.aggregate([\\\"mad\\\"]).values[self.alias][0] #\",\n \"of the vColumn. The vColumn will be transformed. Parameters ----------\",\n \"{} IS NOT NULL LIMIT 20\\\".format( self.alias, dtype, self.alias, self.parent.__genSQL__(),\",\n \"f\\\"'{first_elem}' {op1} {column} AND {column} {op2} '{second_elem}' THEN '{label}'\\\" ]\",\n \"of, max_cardinality, h, ax=ax, **style_kwds, ) # ---# def std(self):\",\n \"1) x ORDER BY verticapy_agg DESC\\\".format( self.alias, bin_spatial_to_str(self.category(), self.alias), self.alias,\",\n \"try: ctype = get_data_types( \\\"SELECT {} AS apply_test_feature FROM {}\",\n \"tail.count = self.parent.shape()[0] tail.offset = offset tail.dtype[self.alias] = self.ctype() tail.name\",\n \"float]), (\\\"nbins\\\", nbins, [float, int]), ] ) if by: self.parent.are_namecols_in(by)\",\n \"all the vColumns. vDataFrame.eval : Evaluates a customized expression. \\\"\\\"\\\"\",\n \"the n smallest elements in the vColumn. \\\"\\\"\\\" check_types([(\\\"n\\\", n,\",\n \": vColumn type iqr : interquartile range kurtosis : kurtosis\",\n \"to normalize.\\\", method=\\\"fetchall\\\", ) for i in range(len(result)): if result[i][2]\",\n \"if not (result) else result[0][0] if not (dropna): n =\",\n \"0.25) AS Q1, APPROXIMATE_PERCENTILE({} USING PARAMETERS percentile = 0.75) AS\",\n \"the spider plot of the input vColumn based on an\",\n \"index_stop = index.stop index_start = index.start if not (isinstance(index_start, int)):\",\n \"( \\\"({} - {}) / ({})\\\".format(\\\"{}\\\", med, mad), \\\"float\\\", \\\"float\\\",\",\n \": q Quantile of the vColumn 'of' (ex: 50% to\",\n \"step, [bool]), ] ) self.parent.are_namecols_in(ts) ts = self.parent.format_colnames(ts) if by:\",\n \"self.ctype() copy_trans = [elem for elem in self.transformations] total =\",\n \"---# def dropna(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Filters the vDataFrame where the\",\n \"copy_trans = [elem for elem in self.transformations] total = self.count()\",\n \"\\\"({} - {}) / {}({} - {})\\\".format( self.alias, cmin, \\\"NULLIFZERO\\\"\",\n \"/ __ `\\\\ / / # | \\\\/ / /\",\n \"an advanced analytical function on a specific vColumn. \\\"\\\"\\\" return\",\n \"the average of the {}'s lower and upper outliers.\\\".format( self.alias\",\n \"int/float/tuple, optional Interval width of the vColumns 1 and 2\",\n \"the tail of the vColumn. \\\"\\\"\\\" check_types([(\\\"limit\\\", limit, [int, float]),\",\n \"total += sys.getsizeof(elem) return total # ---# def min(self): \\\"\\\"\\\"\",\n \"type, category) parent: vDataFrame, optional Parent of the vColumn. One\",\n \"field from the vColumn (only if the vColumn type is\",\n \"Fills missing elements in the vColumn with a user-specified rule.\",\n \"---# def mode(self, dropna: bool = False, n: int =\",\n \"all_new_features += [name] conj = \\\"s were \\\" if len(all_new_features)\",\n \"column must be numerical to use a mean encoding\\\" )\",\n \"data science projects on data stored in Vertica, taking advantage\",\n \"this method will return the mode of the vColumn. Returns\",\n \") ] if method != \\\"robust_zscore\\\": max_floor = 0 for\",\n \"equal to 1\\\") where = \\\" WHERE {} IS NOT\",\n \"all user transformations. If the vDataFrame represents the entire relation,\",\n \"pie_type == \\\"rose\\\" else False if of: self.parent.are_namecols_in(of) of =\",\n \": Encodes the vColumn with Label Encoding. vDataFrame[].get_dummies : Encodes\",\n \"if elem[0] != None else \\\"NULL\\\", elem[2] if elem[2] !=\",\n \"if not (\\\"color\\\" in kwargs): from verticapy.plot import gen_colors kwargs[\\\"color\\\"]\",\n \"{} GROUP BY {};\\\".format( by[0], fun, self.alias, self.parent.__genSQL__(), by[0] )\",\n \"records. vDataFrame[].extract : Extracts the regular expression in each record\",\n \": Minimum of the vColumn 'of'. max : Maximum of\",\n \"kwargs): from verticapy.plot import gen_cmap kwargs[\\\"cmap\\\"] = gen_cmap()[0] else: if\",\n \"\\\".join(query) ) title = \\\"Describes the statics of {} partitioned\",\n \"\\\" if total > 1 else \\\" was \\\" if\",\n \"parameter 'name', you'll be able to solve this issue.\\\" )\",\n \"Number of bins. If empty, an optimized number of bins\",\n \"with the specified name. \\\\u26A0 Warning : SQL code generation\",\n \"elif method == \\\"0ifnull\\\": category, ctype = \\\"int\\\", \\\"bool\\\" else:\",\n \"Maximum number of vColumn distinct elements to be used as\",\n \"pat.replace(\\\"'\\\", \\\"''\\\")) ) # ---# def str_extract(self, pat: str): \\\"\\\"\\\"\",\n \"\\\"'{}'\\\".format(str(elem[0]).replace(\\\"'\\\", \\\"''\\\")) ) result[idx][1] = \\\"NULL\\\" if (elem[1] == None)\",\n \"typing import Union # VerticaPy Modules import verticapy from verticapy.utilities\",\n \"# ---# def dropna(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Filters the vDataFrame where\",\n \"prefix = \\\"approx_\\\" if approx else \\\"\\\" return self.aggregate(func=[prefix +\",\n \"series. \\\"\\\"\\\" check_types( [ (\\\"ts\\\", ts, [str]), (\\\"q\\\", q, [tuple]),\",\n \"= 1.0, kernel: str = \\\"gaussian\\\", nbins: int = 200,\",\n \"with 0 and 1 (1 meaning global outlier). \\\"\\\"\\\" if\",\n \"try: result = executeSQL( \\\"SELECT {}, MIN({}), MAX({}) FROM {}\",\n \"'ts' is greater than November 1993 the 3rd. area: bool,\",\n \"vColumns 1 and 2 to be used as categorical (No\",\n \"method: dict, optional Method to use to impute the missing\",\n \"= val # # Methods # # ---# def aad(self):\",\n \"check_types( [ (\\\"method\\\", method, [str]), (\\\"of\\\", of, [str]), (\\\"max_cardinality\\\", max_cardinality,\",\n \"max_floor -= len(self.transformations) for k in range(max_floor): self.transformations += [(\\\"{}\\\",\",\n \"0 # ---# def __repr__(self): return self.head(limit=verticapy.options[\\\"max_rows\\\"]).__repr__() # ---# def\",\n \"\\\".join(by) ), ) else: cmax, cmin = ( \\\"MAX({}) OVER\",\n \"Computes the vDataFrame input aggregations. \\\"\\\"\\\" return self.aggregate([\\\"variance\\\"]).values[self.alias][0] variance =\",\n \": Computes the vColumn descriptive statistics. \\\"\\\"\\\" check_types([(\\\"k\\\", k, [int,\",\n \"BY 1\\\".format( self.alias, y, y, query, ) query = \\\"SELECT\",\n \") max_floor = len(self.parent[response].transformations) - len( self.transformations ) for k\",\n \"\\\"gaussian\\\", nbins: int = 200, xlim: tuple = None, ax=None,\",\n \"\\\"std\\\"]).values[self.alias] if stddev == 0: warning_message = \\\"Can not normalize\",\n \"NOT NULL\\\".format(self.alias) if (dropna) else \\\"\\\" query = \\\"SELECT {}\",\n \"= 0.05, ): \\\"\\\"\\\" --------------------------------------------------------------------------- Fills the vColumns outliers using\",\n \"func.replace(\\\"{}\\\", self.alias), self.parent.__genSQL__(), self.alias, ), \\\"apply_test_feature\\\", ) category = get_category_from_vertica_type(ctype=ctype)\",\n \"0: nullifzero = 0 avg, stddev = self.aggregate([\\\"avg\\\", \\\"std\\\"]).values[self.alias] if\",\n \"--------------------------------------------------------------------------- Slices the vColumn. The vColumn will be transformed. Parameters\",\n \"from verticapy.utilities import * from verticapy.toolbox import * from verticapy.errors\",\n \"GROUP BY {} ORDER BY _verticapy_cnt_ DESC {}\\\".format( bin_spatial_to_str(self.category(), self.alias),\",\n \"== \\\"topk\\\": assert k >= 2, ParameterError( \\\"Parameter 'k' must\",\n \"approximate quantile). See Also -------- vDataFrame.aggregate : Computes the vDataFrame\",\n \"for k in range(len(distinct_elements)): expr += [ \\\"'{}', {}\\\".format(str(distinct_elements[k]).replace(\\\"'\\\", \\\"''\\\"),\",\n \"# # Modules # # Standard Python Modules import math,\",\n \"interval size to convert to use to convert the vColumn.\",\n \"str, nbins: int = 10): \\\"\\\"\\\" --------------------------------------------------------------------------- Computes the Information\",\n \"\\\"COALESCE({}, {}({}) OVER (PARTITION BY {}))\\\".format( \\\"{}\\\", fun, \\\"{}\\\", \\\",\",\n \"-------- vDataFrame[].describe : Computes the vColumn descriptive statistics. \\\"\\\"\\\" check_types([(\\\"k\\\",\",\n \"optional Number of most occurent elements to return. dropna: bool,\",\n \"columns, method, of, max_cardinality, h, ax=ax, **style_kwds, ) # ---#\",\n \"[int, float])]) if self.isdate(): return self.apply(func=\\\"TIMESTAMPADD(SECOND, -({}), {})\\\".format(x, \\\"{}\\\")) else:\",\n \"mean : Average of the vColumn 'of'. min : Minimum\",\n \"NULL\\\".format(self.alias) if (category in (\\\"None\\\", None)) else \\\" WHERE {}\",\n \"parent=None, catalog: dict = {} ): self.parent, self.alias, self.transformations =\",\n \"int, optional Number of most occurent elements to return. Returns\",\n \"name, bandwidth=bandwidth, kernel=kernel, nbins=nbins, xlim=xlim_tmp, store=False, ) try: result =\",\n \"elements cvar : conditional value at risk dtype : vColumn\",\n \"str, optional Prefix delimitor of the dummies. drop_first: bool, optional\",\n \"empty or invalid. max_cardinality: int, optional Maximum number of vColumn\",\n \"Also -------- vDataFrame.topk : Returns the vColumn most occurent elements.\",\n \"Parameters ---------- *args / **kwargs Any optional parameter to pass\",\n \"), print_time_sql=False, ) except: avg, stddev = ( \\\"AVG({}) OVER\",\n \"\\\"method\\\", method, [ \\\"auto\\\", \\\"mode\\\", \\\"0ifnull\\\", \\\"mean\\\", \\\"avg\\\", \\\"median\\\", \\\"ffill\\\",\",\n \"new_vColumn) self.parent._VERTICAPY_VARIABLES_[\\\"columns\\\"] += [name] all_new_features += [name] conj = \\\"s\",\n \"float optimal bar width. \\\"\\\"\\\" check_types( [(\\\"method\\\", method, [\\\"sturges\\\", \\\"freedman_diaconis\\\",\",\n \"else 0 for k in range(len(distinct_elements) - n): name =\",\n \"BY {} ORDER BY {}\\\".format( bin_spatial_to_str(self.category(), self.alias), self.alias, self.parent.__genSQL__(), self.alias,\",\n \"return self.aggregate(func=[\\\"unique\\\"]).values[self.alias][0] # ---# def pie( self, method: str =\",\n \"median) prod : product range : difference between the max\",\n \"was filled.\\\".format( self.alias ) warnings.warn(warning_message, Warning) return self.parent if isinstance(val,\",\n \"whole number cos : trigonometric cosine cosh : hyperbolic cosine\",\n \"= 0 avg, stddev = self.aggregate([\\\"avg\\\", \\\"std\\\"]).values[self.alias] if stddev ==\",\n \"the vColumn Density Plot. Parameters ---------- by: str, optional vColumn\",\n \"= \\\"\\\" if (method in (\\\"ffill\\\", \\\"pad\\\")) else \\\" DESC\\\"\",\n \"str, optional SQL expression. by: list, optional vColumns used in\",\n \"= True): \\\"\\\"\\\" --------------------------------------------------------------------------- Slices and transforms the vColumn using\",\n \"END\\\" self.apply(func=expr) # ---# def ctype(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns the\",\n \"approximate density function. Increasing this parameter will increase the precision\",\n \"the merging category when using the 'topk' method. RFmodel_params: dict,\",\n \"category) parent: vDataFrame, optional Parent of the vColumn. One vDataFrame\",\n \"return self.transformations[-1][2] # ---# def clip(self, lower=None, upper=None): \\\"\\\"\\\" ---------------------------------------------------------------------------\",\n \"/ spatial / uuid / undefined Returns ------- str vColumn\",\n \"return [item for sublist in query_result for item in sublist]\",\n \"str = \\\"\\\" ): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using\",\n \"ALL \\\".join(query), nbins - 1 ) result = executeSQL( query=query,\",\n \"of most occurent elements to return. Returns ------- tablesample An\",\n \"outliers. After normalizing the data (Z-Score), if the absolute value\",\n \"\\\"varchar\\\", \\\"text\\\", ) elif self.isnum() and method == \\\"same_freq\\\": assert\",\n \"Modules import verticapy from verticapy.utilities import * from verticapy.toolbox import\",\n \"executeSQL( \\\"SELECT {}, MIN({}), MAX({}) FROM {} GROUP BY {}\\\".format(\",\n \": Mean for the numerical and Mode for the categorical\",\n \"to pass to the geopandas plot function. For more information,\",\n \"cardinality). See Also -------- vDataFrame.aggregate : Computes the vDataFrame input\",\n \"trans = (trans, \\\"varchar\\\", \\\"text\\\") if return_enum_trans: return trans else:\",\n \") desc = \\\"\\\" if (method in (\\\"ffill\\\", \\\"pad\\\")) else\",\n \"vColumns. vDataFrame.eval : Evaluates a customized expression. \\\"\\\"\\\" if isinstance(func,\",\n \"self.parent.format_colnames(numcol) assert self.parent[numcol].category() in (\\\"float\\\", \\\"int\\\"), TypeError( \\\"The column 'numcol'\",\n \"isinstance(index_stop, int): if index_stop < 0: index_stop += self.parent.shape()[0] limit\",\n \"in performance. The catalog will be updated when the parent\",\n \"numerical. See Also -------- vDataFrame[].isbool : Returns True if the\",\n \"> 1) Returns ------- tablesample An object containing the result.\",\n \"def value_counts(self, k: int = 30): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns the\",\n \"= \\\"SELECT COUNT({}) AS NAs, MIN({}) AS min, APPROXIMATE_PERCENTILE({} USING\",\n \"[bool]), (\\\"right\\\", right, [bool]), ] ) assert self.isnum() or self.isdate(),\",\n \"included. right: bool, optional How the intervals should be closed.\",\n \"-------- vDataFrame.add_copy : Creates a copy of the vColumn. \\\"\\\"\\\"\",\n \"FROM {} WHERE {} IS NOT NULL) VERTICAPY_SUBTABLE {}\\\".format( self.alias,\",\n \"\\\"approx_\\\" if approx else \\\"\\\" return self.aggregate(func=[prefix + \\\"{}%\\\".format(x *\",\n \"1, \\\"count\\\": self.parent.shape()[0], \\\"percent\\\": 100.0, \\\"unique\\\": 2, \\\"approx_unique\\\": 2, \\\"prod\\\":\",\n \"the vColumn using 'sem' (standard error of mean). Returns -------\",\n \"input functions. Parameters ---------- func: list List of the different\",\n \"null !\\\".format( self.alias ) warnings.warn(warning_message, Warning) return self elif (n\",\n \"vDataFrame[].head : Returns the head of the vColumn. vDataFrame[].tail :\",\n \"an optimized h will be computed. ax: Matplotlib axes object,\",\n \"optional The axes to plot on. **style_kwds Any optional parameter\",\n \"other vColumns. Parameters ---------- add_history: bool, optional If set to\",\n \"({3}{4} USING PARAMETERS percentile = 0.1) AS 'approx_10%', APPROXIMATE_PERCENTILE ({3}{4}\",\n \"{}, NULL))\\\".format( \\\"{}\\\", by[0], \\\", \\\".join( [\\\"{}, {}\\\".format(elem[0], elem[1]) for\",\n \"not in (\\\"log\\\", \\\"mod\\\", \\\"pow\\\", \\\"round\\\"): expr = \\\"{}({})\\\".format(func.upper(), \\\"{}\\\")\",\n \"using 'kurtosis'. Returns ------- float kurtosis See Also -------- vDataFrame.aggregate\",\n \"the mode of the vColumn. Returns ------- str/float/int vColumn nth\",\n \"to use to compute the aggregation. h: int/float/tuple, optional Interval\",\n \"using a user-defined encoding. vDataFrame[].discretize : Discretizes the vColumn. vDataFrame[].label_encode\",\n \"''\\\", \\\"varchar\\\", \\\"text\\\") else: trans = (\\\"{} || ''\\\", \\\"varchar\\\",\",\n \"vColumn will be transformed. Parameters ---------- pat: str Regular expression.\",\n \"even: CASE ... WHEN vColumn = argv[2 * i] THEN\",\n \"to True, the intervals will be closed on the right.\",\n \"\\\"NULL\\\", ) for elem in result if elem[1] != None\",\n \"executeSQL( \\\"SELECT ZEROIFNULL(SUM(LENGTH({}::varchar))) FROM {}\\\".format( bin_spatial_to_str(self.category(), self.alias), self.parent.__genSQL__(), ), title=\\\"Computing\",\n \"tangent cbrt : cube root ceil : value up to\",\n \"(pre_comp != None): return pre_comp assert n >= 1, ParameterError(\\\"Parameter\",\n \"the vDataFrame memory usage. \\\"\\\"\\\" import sys total = (\",\n \") for i in range(len(result)): if result[i][2] == None: pass\",\n \"= max(2.0 * (vColumn_075 - vColumn_025) / (count) ** (1.0\",\n \": Draws the time series. \\\"\\\"\\\" check_types( [ (\\\"ts\\\", ts,\",\n \"of a response. \\\"\\\"\\\" import verticapy.stats as st return self.apply(func=st.decode(str_sql(\\\"{}\\\"),\",\n \"var : variance Other aggregations could work if it is\",\n \"ParameterError( \\\"Length of parameter 'breaks' must be greater or equal\",\n \"[int, float]), (\\\"nbins\\\", nbins, [int, float]), ] ) if of:\",\n \"isinstance(pie_type, str): pie_type = pie_type.lower() check_types( [ (\\\"method\\\", method, [str]),\",\n \"If empty, an optimized h will be computed. ax: Matplotlib\",\n \"List of the different transformations. \\\"\\\"\\\" # # Special Methods\",\n \"\\\"Badr\\\"] Returns ------- vDataFrame The vDataFrame of the search. See\",\n \"== \\\"zscore\\\": if n == 0: nullifzero = 0 avg,\",\n \"= { \\\"index\\\": [item[0] for item in result], \\\"count\\\": [int(item[1])\",\n \"SUM({}) AS events FROM ({}) x GROUP BY 1\\\".format( self.alias,\",\n \"self.alias.replace('\\\"', \\\"\\\") + prefix_sep.replace('\\\"', \\\"_\\\") if not (prefix) else prefix.replace('\\\"',\",\n \"The vDataFrame of the search. See Also -------- vDataFrame.isin :\",\n \"\\\"{}\\\")) # ---# def decode(self, *argv): \\\"\\\"\\\" --------------------------------------------------------------------------- Encodes the\",\n \"# \\\\/ / / # / / # / /\",\n \"func 'x -> {}'.\\\".format( self.alias.replace('\\\"', \\\"\\\"), func.replace(\\\"{}\\\", \\\"x\\\"), ) )\",\n \"lower_when = ( \\\"WHEN {} < {} THEN {} \\\".format(\\\"{}\\\",\",\n \"use to compute the optimal h. auto : Combination of\",\n \"input aggregations. \\\"\\\"\\\" return self.quantile(0.5, approx=approx) # ---# def memory_usage(self):\",\n \"the function's performance can drastically decrease. Returns ------- float quantile\",\n \"self.parent.shape()[0], self.parent.__genSQL__(), dropna, self.alias, topk, ) result = executeSQL( query,\",\n \"datetime.date, int, float], ), ( \\\"end_date\\\", end_date, [str, datetime.datetime, datetime.date,\",\n \"based on an aggregation. Parameters ---------- method: str, optional The\",\n \"else \\\"topk\\\", nbins=nbins, k=nbins, new_category=\\\"Others\\\", return_enum_trans=True, )[0].replace(\\\"{}\\\", self.alias) query =\",\n \"( self.parent.describe( method=\\\"numerical\\\", columns=[self.alias], unique=False ) .transpose() .values[self.alias] ) count,\",\n \"under the License. # # |_ |~) _ _| _\",\n \"to normalize.\\\".format( by[0] ), method=\\\"fetchall\\\", ) cmin = \\\"DECODE({}, {},\",\n \"changing one of \\\" \\\"the parameters ('prefix', 'prefix_sep'), you'll be\",\n \"the method '{}'.\\\".format( self.alias, method ) ) else: raise TypeError(\\\"The\",\n \"\\\\ \\\\ \\\\ \\\\-. \\\\ # \\\\ \\\\__| \\\\ \\\\_____\\\\\",\n \"use a mean encoding\\\" ) max_floor = len(self.parent[response].transformations) - len(\",\n \"date like (date, datetime, timestamp...) or numerical. by: str, optional\",\n \"kernel. kernel: str, optional The method used for the plot.\",\n \"the vColumn using a user-defined encoding. Parameters ---------- argv: object\",\n \") elif self.isnum() and method == \\\"same_freq\\\": assert nbins >=\",\n \"+= [(\\\"{}\\\", self.ctype(), self.category())] self.transformations += [ (\\\"AVG({}) OVER (PARTITION\",\n \"the following: date / int / float / text /\",\n \"in query_result for item in sublist] # ---# def div(self,\",\n \"information, see utilities.tablesample. See Also -------- vDataFrame.iv_woe : Computes the\",\n \"column of that relation. vColumns simplify several processes with its\",\n \"{}) {}\\\".format( self.parent.__genSQL__(), query ) query_result = executeSQL( query=query, title=\\\"Computing\",\n \"on numerical / date-like vColumns.\\\" ) assert len(breaks) >= 2,\",\n \"vColumn is numerical. \\\"\\\"\\\" return self.category() == \\\"date\\\" # ---#\",\n \"warnings.warn(warning_message, Warning) return self elif method == \\\"minmax\\\": if n\",\n \"f\\\"A vColumn has already the alias {name}.\\\\nBy changing the parameter\",\n \"BY split_value::float\\\".format( \\\" UNION ALL \\\".join(query), nbins - 1 )\",\n \": Returns the head of the vColumn. vDataFrame[].tail : Returns\",\n \"See Also -------- vDataFrame.drop: Drops the input vColumns from the\",\n \"statistics of a numerical column for each vColumn category. In\",\n \"Parameters ---------- name: str Name of the copy. Returns -------\",\n \"kernel: str, optional The method used for the plot. gaussian\",\n \"the optimal vColumn bar width. Parameters ---------- method: str, optional\",\n \"start: bool, optional If set to True, the record will\",\n \"[], parent=None, catalog: dict = {} ): self.parent, self.alias, self.transformations\",\n \"MAX({}) AS max FROM {}\\\".format( self.alias, self.alias, self.alias, self.alias, self.alias,\",\n \"each record of the vColumn. vDataFrame[].str_replace : Replaces the regular\",\n \"the vColumn {} using the following mapping:{}\\\".format( self.alias, text_info )\",\n \"sauv[\\\"count\\\"] / self.parent.shape()[0] ) for elem in sauv: if \\\"top\\\"\",\n \"used in the partition. return_trans: bool, optimal If set to\",\n \") expr = \\\"DECODE({}, '{}', 1, 0)\\\".format( \\\"{}\\\", str(distinct_elements[k]).replace(\\\"'\\\", \\\"''\\\")\",\n \"vColumn_max = result sturges = max( float(vColumn_max - vColumn_min) /\",\n \"str / date, optional Input Start Date. For example, time\",\n \"ceiling. Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].date_part :\",\n \"self.alias: [store_usage]} ) return store_usage # ---# def str_contains(self, pat:\",\n \"in self.catalog: total += sys.getsizeof(elem) return total # ---# def\",\n \"Mode for the categorical vColumns. bfill : Back Propagation of\",\n \"\\\"\\\" if (n == 1) else str(int(n)) if isinstance(top, decimal.Decimal):\",\n \"cast, self.parent.__genSQL__(), self.parent.__get_last_order_by__(), index, ) return executeSQL( query=query, title=\\\"Getting the\",\n \"percent FROM {}{} GROUP BY {} ORDER BY _verticapy_cnt_ DESC\",\n \"for idx, column in enumerate(columns): param = {\\\"color\\\": colors[idx %\",\n \"vColumn. \\\"\\\"\\\" return self.apply(func=\\\"ABS({})\\\") # ---# def add(self, x: float):\",\n \"( name.replace(\\\" \\\", \\\"_\\\") .replace(\\\"/\\\", \\\"_\\\") .replace(\\\",\\\", \\\"_\\\") .replace(\\\"'\\\", \\\"_\\\")\",\n \"unit. For example, it can be 'minute' 'hour'... start: bool,\",\n \"brings the logic to the data. # # # Modules\",\n \"{}, ROW_NUMBER() OVER (ORDER BY {}) AS _verticapy_row_nb_ FROM {}\",\n \") ) else: if verticapy.options[\\\"print_info\\\"]: print(\\\"Nothing was filled.\\\") self.transformations =\",\n \"vColumn {} was deleted from the vDataFrame.\\\".format(self.alias) ) return parent\",\n \"an outlier. use_threshold: bool, optional Uses the threshold instead of\",\n \"the function: x -> x^2 + 2 use \\\"POWER({}, 2)\",\n \"\\\"bfill\\\", \\\"backfill\\\", ], ), (\\\"expr\\\", expr, [str]), (\\\"by\\\", by, [list]),\",\n \"= verticapy.options[\\\"temp_schema\\\"] if not (schema): schema = \\\"public\\\" name =\",\n \"to sequentialize # data transformation operations, and offers beautiful graphical\",\n \"this parameter is equal to 0, an optimised interval will\",\n \"'labels' + 1 or parameter 'labels' must be empty.\\\" )\",\n \"the different categories {} to normalize.\\\".format( by[0] ), method=\\\"fetchall\\\", )\",\n \"round(h, 4) elif h > 0.000001: h = round(h, 6)\",\n \"def cut( self, breaks: list, labels: list = [], include_lowest:\",\n \"order_by_ts = \\\", \\\".join([quote_ident(column) + desc for column in order_by])\",\n \"Column.\\\".format( self.alias, response ) ) if verticapy.options[\\\"print_info\\\"]: print(\\\"The mean encoding\",\n \"the different transformations. Each transformation must be similar to the\",\n \"and merge the other into one unique category. h: float,\",\n \"Returns ------- float var See Also -------- vDataFrame.aggregate : Computes\",\n \"\\\"\\\"\\\" return self.transformations[-1][1].lower() dtype = ctype # ---# def date_part(self,\",\n \"{}.\\\".format(self.alias), method=\\\"fetchall\\\", ) return [item for sublist in query_result for\",\n \"by = self.parent.format_colnames(by) from verticapy.plot import boxplot return boxplot(self, by,\",\n \"to the length of parameter 'labels' + 1 or parameter\",\n \"0, 1)\\\" elif method in (\\\"mean\\\", \\\"avg\\\", \\\"median\\\"): fun =\",\n \"\\\"At least 'lower' or 'upper' must have a numerical value\\\"\",\n \"optimal bar width. \\\"\\\"\\\" check_types( [(\\\"method\\\", method, [\\\"sturges\\\", \\\"freedman_diaconis\\\", \\\"fd\\\",\",\n \"val): self.__dict__[attr] = val # # Methods # # ---#\",\n \"------- int vColumn cardinality (or approximate cardinality). See Also --------\",\n \"(sauv[elem] - sauv[\\\"min\\\"]) / ( sauv[\\\"max\\\"] - sauv[\\\"min\\\"] ) except:\",\n \"can only have one parent. catalog: dict, optional Catalog where\",\n \"Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].drop_outliers : Drops\",\n \"--------------------------------------------------------------------------- Aggregates the vColumn using 'max' (Maximum). Returns ------- float/str\",\n \"discretization (must be > 1) k: int, optional The integer\",\n \"0, nbins: int = -1, k: int = 6, new_category:\",\n \"\\\"NULL\\\" self.apply( func=\\\"(CASE WHEN {} < {} THEN {} WHEN\",\n \"boolean. See Also -------- vDataFrame[].isdate : Returns True if the\",\n \"= get_data_types( \\\"SELECT {} AS apply_test_feature FROM {} WHERE {}\",\n \"start: int, step: int): \\\"\\\"\\\" --------------------------------------------------------------------------- Slices the vColumn. The\",\n \"by[0], \\\", \\\".join( [ \\\"{}, {}\\\".format( \\\"'{}'\\\".format(str(elem[0]).replace(\\\"'\\\", \\\"''\\\")) if elem[0]\",\n \"1], result[i], result[i - 1], result[i] ) trans += \\\"\",\n \"vDataFrame.aggregate : Computes the vDataFrame input aggregations. \\\"\\\"\\\" return self.aggregate([\\\"aad\\\"]).values[self.alias][0]\",\n \"If empty, names will be generated. include_lowest: bool, optional If\",\n \"hist return hist(self, method, of, max_cardinality, nbins, h, ax=ax, **style_kwds)\",\n \"__ __ __ __ __ __ __ # /\\\\ \\\\\",\n \"you'll be able to solve this issue.\\\" ) new_vColumn =\",\n \"\\\"\\\"\\\" return self.category() in (\\\"float\\\", \\\"int\\\") # ---# def iv_woe(self,\",\n \"{}, \\\"regr_count\\\": {}, \\\"regr_intercept\\\": {}, \\\"regr_r2\\\": {}, \\\"regr_slope\\\": {}, \\\"regr_sxx\\\":\",\n \"of the copy. Returns ------- vDataFrame self.parent See Also --------\",\n \"using the Robust Z-Score (median and mad). (x - median)\",\n \"vColumn. vDataFrame[].tail : Returns the tail of the vColumn. \\\"\\\"\\\"\",\n \"vColumn using 'product'. Returns ------- float product See Also --------\",\n \"'numcol' must be a vDataFrame column if the method is\",\n \"draw the Plot. start_date: str / date, optional Input Start\",\n \"transformed. Parameters ---------- field: str The field to extract. It\",\n \"otherwise. Returns ------- bool True if the vColumn is numerical.\",\n \"\\\"\\\", plot_median: bool = False, ax=None, **style_kwds, ): \\\"\\\"\\\" ---------------------------------------------------------------------------\",\n \"\\\"\\\"\\\" return self.aggregate([\\\"skewness\\\"]).values[self.alias][0] skew = skewness # ---# def slice(self,\",\n \"AS 'approx_90%', MAX({3}{4}) AS max FROM vdf_table\\\"\\\"\\\".format( category, self.alias, self.parent.shape()[0],\",\n \"\\\" WHERE {} IS NULL\\\".format(self.alias) if (category in (\\\"None\\\", None))\",\n \"category when using the 'topk' method. RFmodel_params: dict, optional Dictionary\",\n \"with One-Hot Encoding. vDataFrame[].label_encode : Encodes the vColumn with Label\",\n \"isnum(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns True if the vColumn is numerical,\",\n \"categories. Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].decode :\",\n \"{}{}ELSE {} END)\\\".format(lower_when, upper_when, \\\"{}\\\") self.apply(func=func) return self.parent # ---#\",\n \"in query_result] index = [\\\"unique\\\", \\\"count\\\"] + [item[0] for item\",\n \"({})\\\".format(\\\"{}\\\", x)) # ---# def nlargest(self, n: int = 10):\",\n \"] ) method = method.lower() self.parent.are_namecols_in(by) by = self.parent.format_colnames(by) nullifzero,\",\n \"Z-Score (median and mad). (x - median) / (1.4826 *\",\n \"float], (\\\"approx\\\", approx, [bool]))]) prefix = \\\"approx_\\\" if approx else\",\n \"self.alias, self.alias, n ) title = \\\"Reads {} {} smallest\",\n \"/ n ** (1 / 3)] sturges : Sturges [CEIL(log2(n))\",\n \"= 0 all_partition = by if method in [\\\"ffill\\\", \\\"pad\\\",\",\n \"1 (1 meaning global outlier). \\\"\\\"\\\" if isinstance(method, str): method\",\n \"if not (schema): schema = \\\"public\\\" tmp_view_name = gen_tmp_name(schema=schema, name=\\\"view\\\")\",\n \"end_date, area, step, ax=ax, **style_kwds, ) # ---# def product(self):\",\n \"= int(max(math.floor(h), 1)) floor_end = -1 if (self.category() == \\\"int\\\")\",\n \"setting this parameter to False, the function's performance can drastically\",\n \"vColumn descriptive statistics. \\\"\\\"\\\" return self.describe(method=\\\"categorical\\\", max_cardinality=k) # ---# def\",\n \"__ __ __ __ __ __ # /\\\\ \\\\ /\",\n \"the vColumn using 'min' (Minimum). Returns ------- float/str minimum See\",\n \"must be greater or equals to 2 in case of\",\n \"True, alpha: float = 0.05, ): \\\"\\\"\\\" --------------------------------------------------------------------------- Fills the\",\n \"of the vColumn records. vDataFrame[].extract : Extracts the regular expression\",\n \"[str]), (\\\"max_cardinality\\\", max_cardinality, [int, float]), (\\\"h\\\", h, [int, float]), (\\\"cat_priority\\\",\",\n \"One-Hot Encoding algorithm. Parameters ---------- prefix: str, optional Prefix of\",\n \"has already the alias {new_name}.\\\\nBy changing the parameter 'new_name', you'll\",\n \"Drops the vColumn missing values. \\\"\\\"\\\" if isinstance(by, str): by\",\n \"lower: float, optional Lower bound. upper: float, optional Upper bound.\",\n \"(method == \\\"cat_stats\\\") and (numcol != \\\"\\\"): numcol = self.parent.format_colnames(numcol)\",\n \"mode(self, dropna: bool = False, n: int = 1): \\\"\\\"\\\"\",\n \"\\\"zscore\\\": if n == 0: nullifzero = 0 avg, stddev\",\n \"--------------------------------------------------------------------------- Aggregates the vColumn using 'std' (Standard Deviation). Returns -------\",\n \"LAST_VALUE({} IGNORE NULLS) OVER ({} ORDER BY {}))\\\".format( \\\"{}\\\", \\\"{}\\\",\",\n \"WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or\",\n \"will be trained if the response is numerical (except ints\",\n \"Parameters ---------- response: str Response vColumn. Returns ------- vDataFrame self.parent\",\n \"parameter to pass to the Matplotlib functions. Returns ------- ax\",\n \"Evaluates a customized expression. \\\"\\\"\\\" if isinstance(func, str_sql): func =\",\n \"bool, optional How the intervals should be closed. If set\",\n \"--------------------------------------------------------------------------- Drops the vColumn from the vDataFrame. Dropping a vColumn\",\n \"Also -------- vDataFrame[].date_part : Extracts a specific TS field from\",\n \"fun == \\\"MEDIAN\\\": fun = \\\"APPROXIMATE_MEDIAN\\\" query = \\\"SELECT {},\",\n \"executeSQL( \\\"SELECT {} FROM {} LIMIT 1\\\".format( new_column.format(self.alias), self.parent.__genSQL__() ),\",\n \"for column in all_cols: try: if (quote_ident(column) in func) or\",\n \"intervals will be closed on the right. Returns ------- vDataFrame\",\n \"use_threshold, [bool]), (\\\"threshold\\\", threshold, [int, float]), ] ) if use_threshold:\",\n \"---# def range_plot( self, ts: str, q: tuple = (0.25,\",\n \"--------------------------------------------------------------------------- Encodes the vColumn using the average of the response\",\n \"Aggregates the vColumn using an input 'quantile'. Parameters ---------- x:\",\n \"THEN '{label}'\\\" ] expr = \\\"CASE WHEN \\\" + \\\"\",\n \"if (dropna) else \\\" \\\" result = executeSQL( \\\"SELECT {}\",\n \"model.get_params() try: model.fit(tmp_view_name, [self.alias], response) query = [ \\\"(SELECT READ_TREE(USING\",\n \"the # entire data science life cycle, uses a ‘pipeline’\",\n \"ax kernel = kernel.lower() from verticapy.learn.neighbors import KernelDensity schema =\",\n \"vColumns. bfill : Back Propagation of the next element (Constant\",\n \"median). It can also be a cutomized aggregation (ex: AVG(column1)\",\n \"\\\" WHEN \\\".join(conditions) + \\\" END\\\" self.apply(func=expr) # ---# def\",\n \"elif idx == 0: op1, close_l = \\\"<\\\", \\\"]\\\" if\",\n \"head of the vColumn. Parameters ---------- limit: int, optional Number\",\n \"offset = max(0, self.parent.shape()[0] - limit) title = \\\"Reads {}.\\\".format(self.alias)\",\n \"self.parent See Also -------- vDataFrame.fill_outliers : Fills the outliers in\",\n \"ax Matplotlib axes object See Also -------- vDataFrame.bar : Draws\",\n \"self.alias ) warnings.warn(warning_message, Warning) return self.parent if isinstance(val, str): val\",\n \"\\\"\\\"\\\" --------------------------------------------------------------------------- Encodes the vColumn using the average of the\",\n \"\\\\ / # \\\\/ # _ # \\\\ / _\",\n \"0.01: h = round(h, 2) elif h > 0.0001: h\",\n \"instead of moving # data around for processing, VerticaPy brings\",\n \"the learning and scoring phases. xlim: tuple, optional Set the\",\n \"elif h > 0.0001: h = round(h, 4) elif h\",\n \"catalog will be updated when the parent vDataFrame is modified.\",\n \"elif method == \\\"0ifnull\\\": new_column = \\\"DECODE({}, NULL, 0, 1)\\\"\",\n \"except: pass total = int(total) conj = \\\"s were \\\"\",\n \"for vColumns 1 and 2 to be used as categorical\",\n \"only categorical aggregations during the computation. cat_stats : Computes statistics\",\n \"[], [] while total < int(float(count / int(nbins))) * int(nbins):\",\n \"\\\"\\\"\\\" check_types( [ (\\\"by\\\", by, [str]), (\\\"method\\\", method, [str]), (\\\"of\\\",\",\n \"--------------------------------------------------------------------------- Applies a function to the vColumn. Parameters ---------- func:\",\n \"NOT NULL GROUP BY {0} ORDER BY COUNT(*)\\\" \\\" DESC\",\n \"add_history: bool = True): \\\"\\\"\\\" --------------------------------------------------------------------------- Drops the vColumn from\",\n \"Parameters ---------- method: str, optional The describe method. auto :\",\n \"length: int, unit: str = \\\"second\\\", start: bool = True):\",\n \"after the comma. Parameters ---------- n: int Number of digits\",\n \"HOUR / ISODOW / ISOWEEK / ISOYEAR / MICROSECONDS /\",\n \"()) AS pt_events FROM ({}) x\\\".format( self.alias, query, ) query\",\n \"self.parent See Also -------- vDataFrame[].apply : Applies a function to\",\n \"[float, int]), ] ) if by: self.parent.are_namecols_in(by) by = self.parent.format_colnames(by)\",\n \"result = [elem[0] for elem in result] elif self.isnum() and\",\n \"\\\"auto\\\", h: float = 0, nbins: int = -1, k:\",\n \"upper and lower outliers by their respective average. null :\",\n \"See Also -------- vDataFrame[].str_count : Computes the number of matches\",\n \"): \\\"\\\"\\\" --------------------------------------------------------------------------- Discretizes the vColumn using the input method.\",\n \"is numerical. See Also -------- vDataFrame[].isbool : Returns True if\",\n \"the MAX. MAX = MIN !\\\".format( self.alias ) warnings.warn(warning_message, Warning)\",\n \"'topk' method. RFmodel_params: dict, optional Dictionary of the Random Forest\",\n \"\\\", \\\".join([quote_ident(column) + desc for column in order_by]) new_column =\",\n \"------- float optimal bar width. \\\"\\\"\\\" check_types( [(\\\"method\\\", method, [\\\"sturges\\\",\",\n \"datetime, timestamp...) or numerical. by: str, optional vColumn to use\",\n \"use a method in zscore|minmax\\\" warnings.warn(warning_message, Warning) return self mad,\",\n \"= len(self.parent[elem].transformations) max_floor -= len(self.transformations) for k in range(max_floor): self.transformations\",\n \"None: self.catalog[elem] = None elif method == \\\"robust_zscore\\\": self.catalog[elem] =\",\n \"vDataFrame self.parent See Also -------- vDataFrame[].decode : Encodes the vColumn\",\n \"if elem[1] != None ] ), ) cmax = \\\"DECODE({},\",\n \"normalizing the data (Z-Score), if the absolute value of the\",\n \"feature by evaluating some conditions. vDataFrame[].discretize : Discretizes the vColumn.\",\n \"with its abstractions. Parameters ---------- alias: str vColumn alias. transformations:\",\n \"Also -------- vDataFrame[].bar : Draws the Bar Chart of vColumn\",\n \"= \\\"SELECT {} AS {}, {} AS ord, {}::int AS\",\n \"pre_comp store_usage = executeSQL( \\\"SELECT ZEROIFNULL(SUM(LENGTH({}::varchar))) FROM {}\\\".format( bin_spatial_to_str(self.category(), self.alias),\",\n \"--------------------------------------------------------------------------- Applies the absolute value function to the input vColumn.\",\n \"warning_message = \\\"The method 'robust_zscore' is available only if the\",\n \"VERTICAPY_OPTIMAL_H_TABLE\\\".format( min_date, self.alias, self.alias, self.parent.__genSQL__() ) query = \\\"SELECT COUNT({})\",\n \"element (ex: top1 for the mode) topk_percent : kth most\",\n \"bool = True): \\\"\\\"\\\" --------------------------------------------------------------------------- Slices and transforms the vColumn\",\n \"str = \\\"zscore\\\", by: list = [], return_trans: bool =\",\n \"Computes the vColumn descriptive statistics. \\\"\\\"\\\" return self.describe(method=\\\"categorical\\\", max_cardinality=k) #\",\n \"n ) title = \\\"Reads {} {} largest elements.\\\".format(self.alias, n)\",\n \"the distinct categories of {}.\\\".format(self.alias), method=\\\"fetchall\\\", ) return [item for\",\n \"if some specific records are in the vDataFrame. \\\"\\\"\\\" if\",\n \"FROM {} LIMIT 1\\\".format( new_column.format(self.alias), self.parent.__genSQL__() ), print_time_sql=False, ) except:\",\n \"percentile = 0.25) AS 'approx_25%', APPROXIMATE_PERCENTILE ({3}{4} USING PARAMETERS percentile\",\n \"Freedman Diaconis [2 * IQR / n ** (1 /\",\n \"- 1], result[i], result[i - 1], result[i] ) trans +=\",\n \"lower bound quantile(alpha) and as upper bound quantile(1-alpha) if 'use_threshold'\",\n \"expr = [\\\"DECODE({}\\\"] text_info = \\\"\\\\n\\\" for k in range(len(distinct_elements)):\",\n \"to the vColumn {} using the following mapping:{}\\\".format( self.alias, text_info\",\n \"Interval width of the vColumns 1 and 2 bars. It\",\n \"\\\"\\\"\\\" --------------------------------------------------------------------------- Returns the distinct categories of the vColumn. Returns\",\n \"'order_by' must be a list of at least one element\",\n \"'{label}'\\\" ] expr = \\\"CASE WHEN \\\" + \\\" WHEN\",\n \"2) + 2)), 1e-99, ) fd = max(2.0 * (vColumn_075\",\n \"datetime.date] = \\\"\\\", end_date: Union[str, datetime.datetime, datetime.date] = \\\"\\\", plot_median:\",\n \"the vColumn \\\" \\\"or simply because of ambiguous columns naming.\\\\nBy\",\n \"step, ax=ax, **style_kwds, ) # ---# def product(self): \\\"\\\"\\\" ---------------------------------------------------------------------------\",\n \"occurent element. See Also -------- vDataFrame.aggregate : Computes the vDataFrame\",\n \"-------- vDataFrame.fill_outliers : Fills the outliers in the vColumn. vDataFrame.outliers\",\n \"following mapping:{}\\\".format( self.alias, text_info ) ) return self.parent # ---#\",\n \"dropna, [bool]), (\\\"n\\\", n, [int, float])]) if n == 1:\",\n \"elements.\\\".format(n, self.alias) return to_tablesample(query, title=title) # ---# def numh(self, method:\",\n \"if index < 0: index += self.parent.shape()[0] query = \\\"SELECT\",\n \"bool, optional If set to True, the lowest element of\",\n \"{} to normalize.\\\".format( by[0] ), method=\\\"fetchall\\\", ) cmin = \\\"DECODE({},\",\n \"\\\"\\\", area: bool = False, step: bool = False, ax=None,\",\n \"doesn't allow slicing having steps different than 1.\\\" ) index_stop\",\n \"for item in result], \\\"count\\\": [int(item[1]) for item in result],\",\n \"h, floor_end ), \\\"varchar\\\", \\\"text\\\", ) else: trans = (\\\"FLOOR({})\",\n \"_repr_html_(self): return self.head(limit=verticapy.options[\\\"max_rows\\\"])._repr_html_() # ---# def __setattr__(self, attr, val): self.__dict__[attr]\",\n \"specific vColumn. \\\"\\\"\\\" return self.parent.aggregate(func=func, columns=[self.alias]).transpose() agg = aggregate #\",\n \"sine sqrt : arithmetic square root tan : trigonometric tangent\",\n \"(\\\"nbins\\\", nbins, [float, int]), ] ) if by: self.parent.are_namecols_in(by) by\",\n \"else \\\"\\\" ) upper_when = ( \\\"WHEN {} > {}\",\n \"occurent element. Parameters ---------- dropna: bool, optional If set to\",\n \"using the Z-Score (avg and std). (x - avg) /\",\n \"6, new_category: str = \\\"Others\\\", RFmodel_params: dict = {}, response:\",\n \"- {}) / {}({})\\\".format( self.alias, avg, \\\"NULLIFZERO\\\" if (nullifzero) else\",\n \"--------------------------------------------------------------------------- Python object which that stores all user transformations. If\",\n \"input aggregations. \\\"\\\"\\\" return self.aggregate([\\\"min\\\"]).values[self.alias][0] # ---# def mode(self, dropna:\",\n \"ax = self.parent.search( \\\"{} = '{}'\\\".format(self.parent[by].alias, column) )[self.alias].density( bandwidth=bandwidth, kernel=kernel,\",\n \"specific TS field from the vColumn. \\\"\\\"\\\" check_types( [ (\\\"length\\\",\",\n \"-------- vDataFrame.eval : Evaluates a customized expression. \\\"\\\"\\\" check_types([(\\\"name\\\", name,\",\n \"\\\"min\\\", \\\"max\\\"]) index = result.values[\\\"index\\\"] result = result.values[self.alias] elif (method\",\n \"see utilities.tablesample. See Also -------- vDataFrame.iv_woe : Computes the Information\",\n \"colors = gen_colors() if not xlim: xmin = self.min() xmax\",\n \"-------- vDataFrame[].str_count : Computes the number of matches for the\",\n \"(1 meaning global outlier). \\\"\\\"\\\" if isinstance(method, str): method =\",\n \": Draws the Bar Chart of the input vColumns based\",\n \"Returns the tail of the vColumn. Parameters ---------- limit: int,\",\n \"---# def isdate(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns True if the vColumn\",\n \"round(h, 2) elif h > 0.0001: h = round(h, 4)\",\n \"was discretized.\\\".format(self.alias) ) return self.parent # ---# def distinct(self, **kwargs):\",\n \"cat_priority: list = [], ax=None, **style_kwds, ): \\\"\\\"\\\" --------------------------------------------------------------------------- Draws\",\n \"Example: Write {\\\"n_estimators\\\": 20, \\\"max_depth\\\": 10} to train a Random\",\n \"h = self.numh() else: h = (self.max() - self.min()) *\",\n \"to False else the lower and upper ZScores. threshold: float,\",\n \"/ binary / spatial / uuid / undefined Returns -------\",\n \": Returns the n smallest elements in the vColumn. \\\"\\\"\\\"\",\n \"method: str, optional Method to use to normalize. zscore :\",\n \"str, optional Response vColumn when method is set to 'smart'.\",\n \"of the vColumn. Parameters ---------- limit: int, optional Number of\",\n \"ORDER BY verticapy_agg DESC\\\".format( self.alias, bin_spatial_to_str(self.category(), self.alias), self.alias, kwargs[\\\"agg\\\"], self.parent.__genSQL__(),\",\n \"self.apply( func=\\\"(CASE WHEN ({} BETWEEN {} AND {}) THEN {}\",\n \"GROUP BY 1 ORDER BY 2 DESC LIMIT {}) VERTICAPY_SUBTABLE\",\n \"return self.category() == \\\"date\\\" # ---# def isin(self, val: list,\",\n \"else: xlim_tmp = [] model = KernelDensity( name, bandwidth=bandwidth, kernel=kernel,\",\n \"self.parent.__add_to_history__( \\\"[AsType]: The vColumn {} was converted to {}.\\\".format( self.alias,\",\n \"vColumn. \\\"\\\"\\\" return self.iloc(limit=limit, offset=-1) # ---# def topk(self, k:\",\n \"\\\"{}\\\", result[i - 1], result[i], result[i - 1], result[i] )\",\n \"( \\\"method\\\", method, [ \\\"auto\\\", \\\"mode\\\", \\\"0ifnull\\\", \\\"mean\\\", \\\"avg\\\", \\\"median\\\",\",\n \"READ_TREE(USING PARAMETERS model_name = '{}', tree_id = {}, format =\",\n \"to the next whole number ln : natural logarithm log\",\n \"vDataFrame input aggregations. \\\"\\\"\\\" return self.aggregate([\\\"stddev\\\"]).values[self.alias][0] stddev = std #\",\n \"= True, alpha: float = 0.05 ): \\\"\\\"\\\" --------------------------------------------------------------------------- Drops\",\n \": Returns the vColumn database type. \\\"\\\"\\\" return self.transformations[-1][2] #\",\n \"\\\"\\\"\\\" --------------------------------------------------------------------------- Computes the optimal vColumn bar width. Parameters ----------\",\n \"bin_spatial_to_str(self.category()), \\\", \\\".join( [ \\\"'{}'\\\".format(str(elem).replace(\\\"'\\\", \\\"''\\\")) for elem in distinct\",\n \"elem in result if elem[1] != None ] ), )\",\n \"0: if nbins <= 0: h = self.numh() else: h\",\n \"def __init__( self, alias: str, transformations: list = [], parent=None,\",\n \"\\\"sign\\\", \\\"sin\\\", \\\"sinh\\\", \\\"sqrt\\\", \\\"tan\\\", \\\"tanh\\\", ], ), (\\\"x\\\", x,\",\n \"correlated features. use_numbers_as_suffix: bool, optional Uses numbers as suffix instead\",\n \"the different records. For example, to check if Badr and\",\n \"if 'use_threshold' is set to False else the lower and\",\n \"---# def mean_encode(self, response: str): \\\"\\\"\\\" --------------------------------------------------------------------------- Encodes the vColumn\",\n \"or (upper != None), ParameterError( \\\"At least 'lower' or 'upper'\",\n \"\\\"{}({}, {})\\\".format(func.upper(), \\\"{}\\\", x) return self.apply(func=expr) # ---# def astype(self,\",\n \"optional The vColumn to use to compute the aggregation. h:\",\n \"data using the input expression. \\\"\\\"\\\" self.parent.filter(\\\"{} IS NOT NULL\\\".format(self.alias))\",\n \"\\\"median\\\") or isinstance(val, float): category, ctype = \\\"float\\\", \\\"float\\\" elif\",\n \"optional Number of elements to display. Returns ------- tablesample An\",\n \"you'll be able to solve this issue.\\\" ) self.add_copy(new_name) parent\",\n \"--------------------------------------------------------------------------- Normalizes the input vColumns using the input method. Parameters\",\n \"impute the vColumn. method: dict, optional Method to use to\",\n \"a response. \\\"\\\"\\\" check_types( [ (\\\"prefix\\\", prefix, [str]), (\\\"prefix_sep\\\", prefix_sep,\",\n \"), (\\\"return_enum_trans\\\", return_enum_trans, [bool]), ] ) method = method.lower() if\",\n \"element of the list will be included. right: bool, optional\",\n \"data (Z-Score), if the absolute value of the record is\",\n \": Encodes the vColumn with user defined Encoding. vDataFrame[].discretize :\",\n \"nbins: int, optional Maximum number of nbins used for the\",\n \"---# def rename(self, new_name: str): \\\"\\\"\\\" --------------------------------------------------------------------------- Renames the vColumn\",\n \"value: str = \\\"\\\"): \\\"\\\"\\\" --------------------------------------------------------------------------- Replaces the regular expression\",\n \"Sets the method to 'numerical' if the vColumn is numerical\",\n \"close_l, close_r = \\\"<=\\\", \\\"<\\\", \\\"[\\\", \\\"[\\\" if idx ==\",\n \"method == \\\"minmax\\\": self.catalog[\\\"min\\\"] = 0 self.catalog[\\\"max\\\"] = 1 self.parent.__add_to_history__(\",\n \"self.parent.format_colnames(of) from verticapy.plot import hist return hist(self, method, of, max_cardinality,\",\n \"vColumn. One vDataFrame can have multiple children vColumns whereas one\",\n \"total # ---# def min(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn\",\n \"Encodes the vColumn with user defined Encoding. vDataFrame[].get_dummies : Encodes\",\n \"the mean encoding of a response. \\\"\\\"\\\" if self.category() in\",\n \"Returns the n smallest elements in the vColumn. Parameters ----------\",\n \"vColumn most occurent elements. \\\"\\\"\\\" if \\\"agg\\\" not in kwargs:\",\n \"axes object \\\"\\\"\\\" columns = [self.alias] check = True if\",\n \"sign sin : trigonometric sine sinh : hyperbolic sine sqrt\",\n \"data stored in Vertica, taking advantage Vertica’s # speed and\",\n \"Parameters ---------- dropna: bool, optional If set to True, NULL\",\n \"return trans else: self.transformations += [trans] sauv = {} for\",\n \"for elem in self.transformations] total = self.count() if method not\",\n \"be empty.\\\" ) conditions, column = [], self.alias for idx\",\n \"of the dummies. prefix_sep: str, optional Prefix delimitor of the\",\n \"optional Lower bound. upper: float, optional Upper bound. Returns -------\",\n \"the vColumn element.\\\", method=\\\"fetchfirstelem\\\", ) else: return getattr(self, index) #\",\n \"vDataFrame.aggregate : Computes the vDataFrame input aggregations. \\\"\\\"\\\" check_types([(\\\"dropna\\\", dropna,\",\n \"expected store usage (unit: b). Returns ------- int vColumn expected\",\n \"_verticapy_row_nb_ IN ({})\\\".format( \\\", \\\".join([\\\"1\\\"] + nth_elems + [str(count)]) )\",\n \"- index_start if limit <= 0: limit = 0 limit\",\n \"to True, the lowest element of the list will be\",\n \"= self.parent force_columns = [ column for column in self.parent._VERTICAPY_VARIABLES_[\\\"columns\\\"]\",\n \"max_floor = len(self.parent[response].transformations) - len( self.transformations ) for k in\",\n \"return self.iloc(limit=limit, offset=-1) # ---# def topk(self, k: int =\",\n \"< {}\\\".format( self.alias, result[\\\"avg\\\"][0], result[\\\"std\\\"][0], threshold ) ) else: p_alpha,\",\n \"ORDER BY 2 DESC LIMIT {}) VERTICAPY_SUBTABLE ORDER BY split_value::float\\\".format(\",\n \"'alpha' parameter. alpha: float, optional Number representing the outliers threshold.\",\n \"(or approximate cardinality). See Also -------- vDataFrame.aggregate : Computes the\",\n \"learning features. It supports the # entire data science life\",\n \"name[1:-1], new_vColumn) self.parent._VERTICAPY_VARIABLES_[\\\"columns\\\"] += [name] self.parent.__add_to_history__( \\\"[Add Copy]: A copy\",\n \"of discretization using the method 'smart'.\\\" ) self.parent.are_namecols_in(response) response =\",\n \"discretized.\\\".format(self.alias) ) return self.parent # ---# def distinct(self, **kwargs): \\\"\\\"\\\"\",\n \"vDataFrame self.parent See Also -------- vDataFrame.case_when : Creates a new\",\n \"ValueError(\\\"Division by 0 is forbidden !\\\") return self.apply(func=\\\"{} / ({})\\\".format(\\\"{}\\\",\",\n \"with {} as Response Column.\\\".format( self.alias, response ) ) if\",\n \"value function to the input vColumn. Returns ------- vDataFrame self.parent\",\n \"index < 0: index += self.parent.shape()[0] query = \\\"SELECT {}{}\",\n \"str(distinct_elements[k]).replace('\\\"', \\\"_\\\") ) ) name = ( name.replace(\\\" \\\", \\\"_\\\")\",\n \"'topk' method. new_category: str, optional The name of the merging\",\n \"non-missing elements cvar : conditional value at risk dtype :\",\n \"return self.aggregate([\\\"sem\\\"]).values[self.alias][0] # ---# def skewness(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the\",\n \"def str_contains(self, pat: str): \\\"\\\"\\\" --------------------------------------------------------------------------- Verifies if the regular\",\n \"new_vColumn) self.parent._VERTICAPY_VARIABLES_[\\\"columns\\\"] += [name] self.parent.__add_to_history__( \\\"[Add Copy]: A copy of\",\n \"of the vColumn 'of'. q% : q Quantile of the\",\n \"], ), (\\\"expr\\\", expr, [str]), (\\\"by\\\", by, [list]), (\\\"order_by\\\", order_by,\",\n \"TS. start_date: str / date, optional Input Start Date. For\",\n \"self.alias, dtype, self.alias, self.parent.__genSQL__(), self.alias ) executeSQL(query, title=\\\"Testing the Type\",\n \"{} for elem in self.catalog: sauv[elem] = self.catalog[elem] self.parent.__update_catalog__(erase=True, columns=[self.alias])\",\n \"the 'topk' method. new_category: str, optional The name of the\",\n \"\\\"\\\"\\\" --------------------------------------------------------------------------- Verifies if the regular expression is in each\",\n \"elem in self.catalog: sauv[elem] = self.catalog[elem] self.parent.__update_catalog__(erase=True, columns=[self.alias]) total =\",\n \"vColumn using 'skewness'. Returns ------- float skewness See Also --------\",\n \"\\\"\\\"\\\" return self.parent.aggregate(func=func, columns=[self.alias]).transpose() agg = aggregate # ---# def\",\n \"title = \\\"Reads {} {} largest elements.\\\".format(self.alias, n) return to_tablesample(query,\",\n \"Replaces the regular expression matches in each of the vColumn\",\n \"{} AND {})\\\".format(self.alias, p_alpha, p_1_alpha) ) return self.parent # ---#\",\n \"optional If set to True, the Median will be drawn.\",\n \"1) and (self.parent[by[0]].nunique() < 50): try: if fun == \\\"MEDIAN\\\":\",\n \"to normalize. zscore : Normalization using the Z-Score (avg and\",\n \"|_) # \\\\/ (/_| | |(_(_|| \\\\/ # / #\",\n \"float/str median See Also -------- vDataFrame.aggregate : Computes the vDataFrame\",\n \"of parameter breaks must be equal to the length of\",\n \"assert k >= 2, ParameterError( \\\"Parameter 'k' must be greater\",\n \"\\\"regr_avgx\\\": {}, \\\"regr_avgy\\\": {}, \\\"regr_count\\\": {}, \\\"regr_intercept\\\": {}, \\\"regr_r2\\\": {},\",\n \"else: query = \\\"SELECT {} FROM (SELECT {} AS {},\",\n \"bool, optional If set to True, NULL values will not\",\n \"vColumn. The aggregations used are the median and two input\",\n \"values will not be considered during the computation. Returns -------\",\n \") warnings.warn(warning_message, Warning) else: distinct_elements = self.distinct() expr = [\\\"DECODE({}\\\"]\",\n \"= self.parent.format_colnames(response) assert self.parent[response].isnum(), TypeError( \\\"The response column must be\",\n \"rule. Parameters ---------- length: int Slice size. unit: str, optional\",\n \"to the data. # # # Modules # # Standard\",\n \"splits when 'method' is set to 'smart'. A RF Regressor\",\n \"bool = False, ax=None, **style_kwds, ): \\\"\\\"\\\" --------------------------------------------------------------------------- Draws the\",\n \"cbrt : cube root ceil : value up to the\",\n \"[bool]), (\\\"h\\\", h, [int, float]), (\\\"response\\\", response, [str]), (\\\"nbins\\\", nbins,\",\n \"MIN({}) AS min, APPROXIMATE_PERCENTILE({} USING PARAMETERS percentile = 0.25) AS\",\n \"-------- vDataFrame[].describe : Computes the vColumn descriptive statistics. \\\"\\\"\\\" return\",\n \"in by]) ) if (by) else \\\"\\\" ) order_by_ts =\",\n \"equal to 2.\\\" ) assert len(breaks) == len(labels) + 1\",\n \"] expr = \\\"CASE WHEN \\\" + \\\" WHEN \\\".join(conditions)\",\n \") result = [elem[0] for elem in result] elif self.isnum()\",\n \"use to partition the data. bandwidth: float, optional The bandwidth\",\n \"0\\\".format( func.replace(\\\"{}\\\", self.alias), self.parent.__genSQL__(), self.alias, ), \\\"apply_test_feature\\\", ) category =\",\n \"(use_numbers_as_suffix) else '\\\"{}{}\\\"'.format( prefix, str(distinct_elements[k]).replace('\\\"', \\\"_\\\") ) ) name =\",\n \"iqr : interquartile range kurtosis : kurtosis jb : Jarque-Bera\",\n \"pre_comp assert self.isnum() or self.isdate(), ParameterError( \\\"numh is only available\",\n \"str = \\\"\\\", max_cardinality: int = 6, h: float =\",\n \"\\\"VERTICAPY_NOT_PRECOMPUTED\\\": return pre_comp store_usage = executeSQL( \\\"SELECT ZEROIFNULL(SUM(LENGTH({}::varchar))) FROM {}\\\".format(\",\n \"vColumn. vDataFrame[].label_encode : Encodes the vColumn with Label Encoding. vDataFrame[].mean_encode\",\n \"self.parent.__genSQL__(), query ) query_result = executeSQL( query=query, title=\\\"Computing the descriptive\",\n \"def iloc(self, limit: int = 5, offset: int = 0):\",\n \"if (isinstance(lower, (float, int))) else \\\"\\\" ) upper_when = (\",\n \"title=\\\"Getting the vColumn element.\\\", method=\\\"fetchfirstelem\\\", ) else: return getattr(self, index)\",\n \"), \\\"MIN({}) OVER (PARTITION BY {})\\\".format( self.alias, \\\", \\\".join(by) ),\",\n \"input vColumn based on an aggregation. Parameters ---------- by: str,\",\n \"of the vColumn 'of'. min : Minimum of the vColumn\",\n \"increase the precision but will also increase the time of\",\n \"True if len(args) > 0: column = args[0] elif \\\"column\\\"\",\n \"# ---# def add(self, x: float): \\\"\\\"\\\" --------------------------------------------------------------------------- Adds the\",\n \"else: h = (self.max() - self.min()) * 1.01 / nbins\",\n \"{} using the MIN and the MAX. MAX = MIN\",\n \"is numerical or of type date like. Optimized h will\",\n \"(self.category() == \\\"float\\\"): trans = ( \\\"'[' || FLOOR({} /\",\n \"- pt_events) * ZEROIFNULL(LN(pt_non_events / NULLIFZERO(pt_events))) END AS iv FROM\",\n \"BETWEEN {} AND {} THEN '[{};{}]' \\\".format( \\\"{}\\\", result[i -\",\n \"\\\"VERTICAPY_NOT_PRECOMPUTED\\\": return pre_comp assert self.isnum() or self.isdate(), ParameterError( \\\"numh is\",\n \"pass self.parent.__add_to_history__( \\\"[Discretize]: The vColumn {} was discretized.\\\".format(self.alias) ) return\",\n \"lesser than November 1993 the 3rd. end_date: str / date,\",\n \"# ---# def __getitem__(self, index): if isinstance(index, slice): assert index.step\",\n \"!= None), ParameterError( \\\"At least 'lower' or 'upper' must have\",\n \"used to compute the best splits when 'method' is set\",\n \"(method != \\\"cat_stats\\\") or (numcol), ParameterError( \\\"The parameter 'numcol' must\",\n \"x GROUP BY 1\\\".format( self.alias, y, y, query, ) query\",\n \"and mad). (x - median) / (1.4826 * mad) minmax\",\n \"= \\\"Normalize doesn't work on booleans\\\".format(self.alias) warnings.warn(warning_message, Warning) elif self.isnum():\",\n \"median : median min : minimum mode : most occurent\",\n \"places sign : arithmetic sign sin : trigonometric sine sinh\",\n \"\\\"COALESCE({}, DECODE({}, {}, NULL))\\\".format( \\\"{}\\\", by[0], \\\", \\\".join( [\\\"{}, {}\\\".format(elem[0],\",\n \"()) AS pt_non_events, events / NULLIFZERO(SUM(events) OVER ()) AS pt_events\",\n \"the vColumn with One-Hot Encoding. vDataFrame[].label_encode : Encodes the vColumn\",\n \"vColumn is numerical. See Also -------- vDataFrame[].isbool : Returns True\",\n \"if \\\"count\\\" in sauv: self.catalog[\\\"count\\\"] = int(sauv[\\\"count\\\"]) + total self.catalog[\\\"percent\\\"]\",\n \"float]), ( \\\"method\\\", method, [\\\"auto\\\", \\\"smart\\\", \\\"same_width\\\", \\\"same_freq\\\", \\\"topk\\\"], ),\",\n \"prefix, str(distinct_elements[k]).replace('\\\"', \\\"_\\\") ) ) assert not (self.parent.is_colname_in(name)), NameError( f\\\"A\",\n \"---------- ts: str TS (Time Series) vColumn to use to\",\n \"[tuple]), ( \\\"start_date\\\", start_date, [str, datetime.datetime, datetime.date, int, float], ),\",\n \"statistical aggregations: min, max, median, unique... depending on the input\",\n \"result = self.aggregate(func=[\\\"std\\\", \\\"avg\\\"]).transpose().values p_alpha, p_1_alpha = ( -threshold *\",\n \"\\\"int\\\") # ---# def iv_woe(self, y: str, nbins: int =\",\n \"time series rule. \\\"\\\"\\\" return self.apply(func=\\\"DATE_PART('{}', {})\\\".format(field, \\\"{}\\\")) # ---#\",\n \"{}.\\\".format(self.alias) tail = to_tablesample( \\\"SELECT {} AS {} FROM {}{}\",\n \"start_date, end_date, plot_median, ax=ax, **style_kwds, ) # ---# def rename(self,\",\n \"in the final generated SQL code. Note: Dropping a vColumn\",\n \") return self.parent one_hot_encode = get_dummies # ---# def head(self,\",\n \"/ / / # \\\\ / / / # \\\\_______/\",\n \"pie_type: str, optional The type of pie chart. auto :\",\n \"else \\\"\\\" if index < 0: index += self.parent.shape()[0] query\",\n \"# | \\\\/ / / / # |______ / /\",\n \"display. Returns ------- tablesample An object containing the result. For\",\n \"the histogram of the vColumn based on an aggregation. Parameters\",\n \"of the vDataFrame parent and do not apply it. This\",\n \"delattr(self.parent, self.alias) except: self.parent._VERTICAPY_VARIABLES_[\\\"exclude_columns\\\"] += [self.alias] if add_history: self.parent.__add_to_history__( \\\"[Drop]:\",\n \"bool True if the vColumn is boolean. See Also --------\",\n \"code. Note: Dropping a vColumn can make the vDataFrame \\\"heavier\\\"\",\n \"---------- val: list List of the different records. For example,\",\n \"False otherwise. Returns ------- bool True if the vColumn is\",\n \"of points to use to evaluate the approximate density function.\",\n \"parameter to pass to the geopandas plot function. For more\",\n \"of the ceiling. Returns ------- vDataFrame self.parent See Also --------\",\n \"\\\"numh is only available on type numeric|date\\\" ) if self.isnum():\",\n \"max_cardinality + 1) query = \\\"WITH vdf_table AS (SELECT *\",\n \"This parameter is used for testing purpose. Returns ------- vDataFrame\",\n \": Maximum of the vColumn 'of'. sum : Sum of\",\n \"# _ # \\\\ / _ __|_. _ _ |_)\",\n \"= \\\"<\\\", \\\"<=\\\", \\\"]\\\", \\\"]\\\" else: op1, op2, close_l, close_r\",\n \"method: str = \\\"density\\\", of: str = \\\"\\\", max_cardinality: int\",\n \"when method is set to 'smart'. return_enum_trans: bool, optional Returns\",\n \">= 2, ParameterError( \\\"Parameter 'k' must be greater or equals\",\n \"optional vColumn to use to partition the data. bandwidth: float,\",\n \"compute the Equal Frequency discretization\\\" ) total, query, nth_elems =\",\n \"verticapy.plot import pie return pie( self, method, of, max_cardinality, h,\",\n \"and Mode for the categorical vColumns. bfill : Back Propagation\",\n \"str): \\\"\\\"\\\" --------------------------------------------------------------------------- Extracts the regular expression in each record\",\n \"\\\"''\\\")) if elem[0] != None else \\\"NULL\\\", elem[1] if elem[1]\",\n \"order_by]) new_column = \\\"COALESCE({}, LAST_VALUE({} IGNORE NULLS) OVER ({} ORDER\",\n \"= self.parent.get_columns(), 0 for column in all_cols: try: if (quote_ident(column)\",\n \"\\\"float\\\") ] self.parent.__update_catalog__(erase=True, columns=[self.alias]) self.parent.__add_to_history__( \\\"[Mean Encode]: The vColumn {}\",\n \"of the vColumn. \\\"\\\"\\\" return self.iloc(limit=limit) # ---# def hist(\",\n \"the input vColumn. \\\"\\\"\\\" check_types( [ (\\\"breaks\\\", breaks, [list]), (\\\"labels\\\",\",\n \"if the vDataFrame has been transformed multiple times, so it's\",\n \"\\\"\\\"\\\" check_types([(\\\"x\\\", x, [int, float])]) assert x != 0, ValueError(\\\"Division\",\n \"can be the result of using previously the method on\",\n \"else \\\"\\\" return self.aggregate(func=[prefix + \\\"{}%\\\".format(x * 100)]).values[self.alias][ 0 ]\",\n \"= self.parent.format_colnames(column) columns += [column] if not (\\\"cmap\\\" in kwargs):\",\n \"attr, val): self.__dict__[attr] = val # # Methods # #\",\n \"and do not apply it. This parameter is very useful\",\n \"to compute the aggregation. max_cardinality: int, optional Maximum number of\",\n \"query = \\\"SELECT * FROM {} WHERE {} IS NOT\",\n \"\\\"SELECT {}, {} FROM {} LIMIT 1\\\".format( avg, stddev, self.parent.__genSQL__()\",\n \"self.catalog[\\\"max\\\"] = 1 self.parent.__add_to_history__( \\\"[Normalize]: The vColumn '{}' was normalized\",\n \"--------------------------------------------------------------------------- Aggregates the vColumn using 'var' (Variance). Returns ------- float\",\n \"- limit) title = \\\"Reads {}.\\\".format(self.alias) tail = to_tablesample( \\\"SELECT\",\n \"of the vColumn. vDataFrame[].tail : Returns the tail of the\",\n \"method, [str]), (\\\"of\\\", of, [str]), (\\\"max_cardinality\\\", max_cardinality, [int, float]), (\\\"nbins\\\",\",\n \"optional The integer k of the 'topk' method. new_category: str,\",\n \"/ QUARTER / SECOND / TIME ZONE / TIMEZONE_HOUR /\",\n \"schema = \\\"public\\\" tmp_view_name = gen_tmp_name(schema=schema, name=\\\"view\\\") tmp_model_name = gen_tmp_name(schema=schema,\",\n \"1) else \\\"LIMIT {}\\\".format(k) dropna = \\\" WHERE {} IS\",\n \"use to partition the data. method: str, optional The method\",\n \"self.parent.__genSQL__() ) p_alpha, p_1_alpha = executeSQL( query=query, title=\\\"Computing the quantiles\",\n \"cos : trigonometric cosine cosh : hyperbolic cosine cot :\",\n \"aggregate the data. count : Number of elements. density :\",\n \"\\\"Parameter 'response' can not be empty in case of discretization\",\n \"\\\\ \\\\ \\\\'/ \\\\ \\\\ \\\\____ \\\\ \\\\ \\\\/\\\\ \\\\\",\n \"the time of the learning and scoring phases. xlim: tuple,\",\n \"DESC {}\\\".format( bin_spatial_to_str(self.category(), self.alias), self.alias, self.parent.shape()[0], self.parent.__genSQL__(), dropna, self.alias, topk,\",\n \"bin_spatial_to_str(self.category(), self.alias), self.alias, kwargs[\\\"agg\\\"], self.parent.__genSQL__(), self.alias, ) query_result = executeSQL(\",\n \"AS _verticapy_row_nb_ FROM {} WHERE {} IS NOT NULL) VERTICAPY_SUBTABLE\",\n \"vDataFrame[].extract : Extracts the regular expression in each record of\",\n \"= False, n: int = 1): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns the\",\n \"bar(self, method, of, max_cardinality, nbins, h, ax=ax, **style_kwds) # ---#\",\n \"of the mean skewness : skewness sum : sum std\",\n \"DESC LIMIT {}\\\".format( self.parent.__genSQL__(), self.alias, self.alias, n ) title =\",\n \"vDataFrame. Parameters ---------- name: str Name of the copy. Returns\",\n \"Also -------- vDataFrame.boxplot : Draws the Box Plot of the\",\n \"sauv: if \\\"top\\\" in elem: if \\\"percent\\\" in elem: self.catalog[elem]\",\n \"is boolean, False otherwise. Returns ------- bool True if the\",\n \"element). 0ifnull : 0 when the vColumn is null, 1\",\n \"List of the different aggregation. aad : average absolute deviation\",\n \"[(\\\"{}\\\", self.ctype(), self.category())] self.transformations += [(func, ctype, category)] self.parent.__update_catalog__(erase=True, columns=[self.alias])\",\n \"if the vColumn is boolean. vDataFrame[].isdate : Returns True if\",\n \"x, [int, float])]) return self.apply(func=\\\"{} * ({})\\\".format(\\\"{}\\\", x)) # ---#\",\n \"only have one parent. catalog: dict, optional Catalog where each\",\n \"\\\"<=\\\", \\\"[\\\" elif idx == 0: op1, close_l = \\\"<\\\",\",\n \"Start of the slicing. step: int Size of the slicing.\",\n \"mad(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using 'mad' (median absolute\",\n \"---# def __len__(self): return int(self.count()) # ---# def __nonzero__(self): return\",\n \"jb : Jarque-Bera index mad : median absolute deviation max\",\n \") return parent # ---# def drop_outliers( self, threshold: float\",\n \"natural logarithm log : logarithm log10 : base 10 logarithm\",\n \"self.aggregate([\\\"avg\\\"]).values[self.alias][0] mean = avg # ---# def bar( self, method:\",\n \"= \\\"COALESCE({}, '{}')\\\".format(\\\"{}\\\", val) elif expr: new_column = \\\"COALESCE({}, {})\\\".format(\\\"{}\\\",\",\n \"{} IS NOT NULL \\\".format(self.alias) if (dropna) else \\\" \\\"\",\n \"self.parent.__genSQL__(), where, self.alias, n ), title=\\\"Computing the mode.\\\", method=\\\"fetchall\\\", )\",\n \"std). (x - avg) / std robust_zscore : Normalization using\",\n \"index.start if not (isinstance(index_start, int)): index_start = 0 if index_start\",\n \"executeSQL( \\\"SELECT {}, AVG({}), STDDEV({}) FROM {} GROUP BY {}\\\".format(\",\n \"with a user-specified rule. Parameters ---------- val: int/float/str, optional Value\",\n \"Returns the vColumn expected store usage (unit: b). Returns -------\",\n \"\\\\/ # _ # \\\\ / _ __|_. _ _\",\n \"Computes the vDataFrame input aggregations. \\\"\\\"\\\" return self.aggregate([\\\"sum\\\"]).values[self.alias][0] # ---#\",\n \"= 0 THEN 0 ELSE (pt_non_events - pt_events) * ZEROIFNULL(LN(pt_non_events\",\n \"method, of, max_cardinality, h, donut, rose, ax=None, **style_kwds, ) #\",\n \"[int])]) self.parent.are_namecols_in(y) y = self.parent.format_colnames(y) assert self.parent[y].nunique() == 2, TypeError(\",\n \"where = \\\" WHERE {} IS NOT NULL \\\".format(self.alias) if\",\n \"vColumn can make the vDataFrame \\\"heavier\\\" if it is used\",\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)\",\n \"\\\"\\\"\\\" --------------------------------------------------------------------------- Fills the vColumns outliers using the input method.\",\n \") if by: self.parent.are_namecols_in(by) by = self.parent.format_colnames(by) columns = [self.alias,\",\n \"Drops the input vColumns from the vDataFrame. \\\"\\\"\\\" check_types([(\\\"add_history\\\", add_history,\",\n \"str New type. Returns ------- vDataFrame self.parent See Also --------\",\n \"float]), (\\\"h\\\", h, [int, float]), (\\\"cat_priority\\\", cat_priority, [list]), ] )\",\n \"---# def describe( self, method: str = \\\"auto\\\", max_cardinality: int\",\n \"the vColumn using 'var' (Variance). Returns ------- float var See\",\n \"index_stop < 0: index_stop += self.parent.shape()[0] limit = index_stop -\",\n \"------- float skewness See Also -------- vDataFrame.aggregate : Computes the\",\n \"--------------------------------------------------------------------------- Returns the k most occurent elements and their distributions\",\n \"/ / # \\\\ / / / # \\\\_______/ /\",\n \"return self.aggregate([\\\"skewness\\\"]).values[self.alias][0] skew = skewness # ---# def slice(self, length:\",\n \"See Also -------- vDataFrame.analytic : Adds a new vColumn to\",\n \"copy_trans] raise QueryError(\\\"{}\\\\nAn Error happened during the filling.\\\".format(e)) if total\",\n \"/ std robust_zscore : Normalization using the Robust Z-Score (median\",\n \"than the threshold it will be considered as an outlier.\",\n \"x: float): \\\"\\\"\\\" --------------------------------------------------------------------------- Multiplies the vColumn by the input\",\n \"\\\"categorical\\\", \\\"cat_stats\\\"]), (\\\"max_cardinality\\\", max_cardinality, [int, float]), (\\\"numcol\\\", numcol, [str]), ]\",\n \"Also -------- vDataFrame.astype : Converts the vColumns to the input\",\n \"] ) if of: self.parent.are_namecols_in(of) of = self.parent.format_colnames(of) from verticapy.plot\",\n \") ) return self.parent except Exception as e: raise QueryError(\",\n \"\\\"\\\", start_date: Union[str, datetime.datetime, datetime.date] = \\\"\\\", end_date: Union[str, datetime.datetime,\",\n \"for item in result], \\\"percent\\\": [float(round(item[2], 3)) for item in\",\n \"not (method == \\\"categorical\\\")) or ( method == \\\"is_numeric\\\" ):\",\n \"different aggregation. aad : average absolute deviation approx_unique : approximative\",\n \"the vColumn with Label Encoding. vDataFrame[].mean_encode : Encodes the vColumn\",\n \"\\\"\\\"\\\" --------------------------------------------------------------------------- Returns True if the vColumn is numerical, False\",\n \"optimized number of nbins will be computed. h: float, optional\",\n \"Maximum number of the vColumn distinct elements to be used\",\n \"mad), \\\"float\\\", \\\"float\\\", ) ] else: warning_message = \\\"Can not\",\n \"self.parent.are_namecols_in(column) column = self.parent.format_colnames(column) columns += [column] if not (\\\"cmap\\\"\",\n \"---# def distinct(self, **kwargs): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns the distinct categories\",\n \"types to varchar. same_freq : Computes bins with the same\",\n \"< 0: offset = max(0, self.parent.shape()[0] - limit) title =\",\n \"{}) OVER () FROM {} LIMIT 1\\\".format( alpha, self.alias, alpha,\",\n \"self.parent[numcol].category() in (\\\"float\\\", \\\"int\\\"), TypeError( \\\"The column 'numcol' must be\",\n \"import ts_plot return ts_plot( self, ts, by, start_date, end_date, area,\",\n \"the data (Z-Score), if the absolute value of the record\",\n \"\\\\/_/ \\\\/_/ \\\\/_/ \\\\/_/ # # # ---# class vColumn(str_sql):\",\n \"is greater than November 1993 the 3rd. plot_median: bool, optional\",\n \"solve this issue.\\\" ) self.add_copy(new_name) parent = self.drop(add_history=False) parent.__add_to_history__( \\\"[Rename]:\",\n \"be converted to {}\\\".format( e, self.alias, dtype ) ) #\",\n \"Usage of the vColumn {}.\\\".format(self.alias), method=\\\"fetchfirstelem\\\", ) self.parent.__update_catalog__( {\\\"index\\\": [\\\"store_usage\\\"],\",\n \"by: str = \\\"\\\", bandwidth: float = 1.0, kernel: str\",\n \"vColumn_max = ( result[0], result[3], result[4], result[6], result[7], ) elif\",\n \"Fills the outliers in the vColumn. vDataFrame.outliers : Adds a\",\n \"\\\", \\\".join(by) ), ) else: avg, stddev = ( \\\"AVG({})\",\n \"value to a specified number of decimal places sign :\",\n \"APPROXIMATE_PERCENTILE ({3}{4} USING PARAMETERS percentile = 0.9) AS 'approx_90%', MAX({3}{4})\",\n \"picked or computed) nbins: int, optional Number of nbins. If\",\n \"or numerical. by: str, optional vColumn to use to partition\",\n \"next whole number ln : natural logarithm log : logarithm\",\n \"in range(len(breaks) - 1): first_elem, second_elem = breaks[idx], breaks[idx +\",\n \"# ---# def nsmallest(self, n: int = 10): \\\"\\\"\\\" ---------------------------------------------------------------------------\",\n \"categories will be filtered. ax: Matplotlib axes object, optional The\",\n \"to aggregate the data. count : Number of elements. density\",\n \"above. The idea is simple: instead of moving # data\",\n \"not normalize {} using a Z-Score - The Standard Deviation\",\n \"method == \\\"zscore\\\": self.catalog[\\\"mean\\\"] = 0 self.catalog[\\\"std\\\"] = 1 elif\",\n \"\\\"mode\\\" total = self.count() if (method == \\\"mode\\\") and (val\",\n \"h, [int, float]), (\\\"cat_priority\\\", cat_priority, [list]), ] ) if by:\",\n \"in zscore|minmax\\\" warnings.warn(warning_message, Warning) return self mad, med = self.aggregate([\\\"mad\\\",\",\n \"\\\"float\\\", \\\"float\\\", ) ] elif method == \\\"robust_zscore\\\": if n\",\n \"unit: str, optional Slice size unit. For example, it can\",\n \"If the function has two arguments (example, power or mod),\",\n \"+ total) / self.parent.shape()[0] ) except: pass total = int(total)\",\n \"the input vColumns using the input method. Parameters ---------- method:\",\n \"matches in each of the vColumn records by an input\",\n \"== \\\"same_freq\\\") or ( self.isnum() and method == \\\"smart\\\" ):\",\n \"isinstance(by, str): by = [by] check_types( [ (\\\"method\\\", method, [\\\"zscore\\\",\",\n \"if self.category() in [\\\"date\\\", \\\"float\\\"]: warning_message = ( \\\"label_encode is\",\n \"percentile = 0.9) AS 'approx_90%', MAX({3}{4}) AS max FROM vdf_table\\\"\\\"\\\".format(\",\n \"= self.count() if (method == \\\"mode\\\") and (val == None):\",\n \"else: if verticapy.options[\\\"print_info\\\"]: print(\\\"Nothing was filled.\\\") self.transformations = [elem for\",\n \"_ _| _ /~\\\\ _ |. # |_)\\\\/ |_)(_|(_|| \\\\_/|_|(_|||\",\n \"will filter the data when 'ts' is lesser than November\",\n \"Bar Chart of vColumn based on an aggregation. \\\"\\\"\\\" check_types(\",\n \"/ / /\\\\ ___\\\\ /\\\\ __ \\\\ /\\\\ \\\\ /\\\\\",\n \"in kwargs): from verticapy.plot import gen_colors kwargs[\\\"color\\\"] = gen_colors()[0] if\",\n \"NULLIFZERO(SUM(events) OVER ()) AS pt_events FROM ({}) x\\\".format( self.alias, query,\",\n \"\\\"fd\\\", \\\"auto\\\"])] ) method = method.lower() if method == \\\"auto\\\":\",\n \"= \\\"(SELECT {} FROM {}{} OFFSET {}{}) VERTICAPY_SUBTABLE\\\".format( self.alias, self.parent.__genSQL__(),\",\n \"of elements. density : Percentage of the distribution. mean :\",\n \"data. Parameters ---------- new_name: str The new vColumn alias. Returns\",\n \"as e: raise QueryError( \\\"{}\\\\nError when applying the func 'x\",\n \"NULLIFZERO(SUM(non_events) OVER ()) AS pt_non_events, events / NULLIFZERO(SUM(events) OVER ())\",\n \"of the above. The idea is simple: instead of moving\",\n \"the vDataFrame expected store usage. \\\"\\\"\\\" pre_comp = self.parent.__get_catalog_value__(self.alias, \\\"store_usage\\\")\",\n \": Draws the Bar Chart of vColumn based on an\",\n \"numcol, self.alias ) values = to_tablesample(query, title=title).values elif ( ((distinct_count\",\n \"text_info ) ) return self.parent # ---# def mad(self): \\\"\\\"\\\"\",\n \"IS NOT NULL GROUP BY 1 ORDER BY 2 DESC\",\n \"defined. numerical : Uses popular numerical aggregations during the computation.\",\n \"nth_elems = nb, [], [] while total < int(float(count /\",\n \"element.\\\", method=\\\"fetchfirstelem\\\", ) else: return getattr(self, index) # ---# def\",\n \"must be one of the following: CENTURY / DAY /\",\n \"self.ctype(), self.category())] self.transformations += final_transformation sauv = {} for elem\",\n \"int(math.floor(math.log(count, 2) + 2)), 1e-99, ) fd = max(2.0 *\",\n \"alpha], [self.alias]) .transpose() .values[self.alias] ) self.parent.filter( \\\"({} BETWEEN {} AND\",\n \"IS NOT NULL\\\".format(self.alias)) return self.parent # ---# def fill_outliers( self,\",\n \"NULLIFZERO(pt_events))) END AS woe, CASE WHEN non_events = 0 OR\",\n \"--------------------------------------------------------------------------- Encodes the vColumn using a user-defined encoding. Parameters ----------\",\n \"= \\\"SELECT {}{} FROM {}{} OFFSET {} LIMIT 1\\\".format( self.alias,\",\n \"\\\"rose\\\"]), ] ) donut = True if pie_type == \\\"donut\\\"\",\n \"each record of the vColumn. The vColumn will be transformed.\",\n \"str, optional Prefix of the dummies. prefix_sep: str, optional Prefix\",\n \"and offers beautiful graphical options. # # VerticaPy aims to\",\n \"using. Returns ------- tablesample An object containing the result. For\",\n \"Converts the vColumn to the input type. Parameters ---------- dtype:\",\n \"numeric|date\\\" ) if self.isnum(): result = ( self.parent.describe( method=\\\"numerical\\\", columns=[self.alias],\",\n \"self.apply( func=\\\"TIME_SLICE({}, {}, '{}', '{}')\\\".format( \\\"{}\\\", length, unit.upper(), start_or_end )\",\n \"otherwise. Returns ------- bool True if the vColumn category is\",\n \"int(float(count / int(nbins))) * int(nbins): nth_elems += [str(total)] total +=\",\n \"( \\\"({} - {}) / {}({})\\\".format( \\\"{}\\\", avg, \\\"NULLIFZERO\\\" if\",\n \"\\\"\\\"\\\" --------------------------------------------------------------------------- Drops the vColumn from the vDataFrame. Dropping a\",\n \"AS {}, {} AS ord, {}::int AS {} FROM {}\\\".format(\",\n \"lesser than the lower bound to the lower bound itself\",\n \"vDataFrame.aggregate : Computes the vDataFrame input aggregations. \\\"\\\"\\\" return self.aggregate([\\\"variance\\\"]).values[self.alias][0]\",\n \"Also -------- vDataFrame[].fill_outliers : Fills the vColumn outliers using the\",\n \"[], self.distinct() if len(cat) == 1: lp, rp = \\\"(\\\",\",\n \"the parameter is empty or invalid. max_cardinality: int, optional Maximum\",\n \"self.isbool(): warning_message = \\\"Normalize doesn't work on booleans\\\".format(self.alias) warnings.warn(warning_message, Warning)\",\n \": Extracts the regular expression in each record of the\",\n \"--------------------------------------------------------------------------- Returns the category of the vColumn. The category will\",\n \"the optimal h.\\\", method=\\\"fetchrow\\\", ) count, vColumn_min, vColumn_025, vColumn_075, vColumn_max\",\n \"partition the TS. start_date: str / date, optional Input Start\",\n \"for elem in copy_trans] raise QueryError(\\\"{}\\\\nAn Error happened during the\",\n \"the statics of {} partitioned by {}.\\\".format( numcol, self.alias )\",\n \"max_cardinality, [int, float]), (\\\"h\\\", h, [int, float]), (\\\"cat_priority\\\", cat_priority, [list]),\",\n \"and max). (x - min) / (max - min) by:\",\n \"self.parent.shape()[0] self.catalog[\\\"percent\\\"] = 100 self.parent.__add_to_history__( \\\"[Label Encoding]: Label Encoding was\",\n \"str = \\\"density\\\", of: str = \\\"\\\", max_cardinality: int =\",\n \"else: final_transformation = [ ( \\\"({} - {}) / ({})\\\".format(\\\"{}\\\",\",\n \"(\\\"of\\\", of, [str]), (\\\"max_cardinality\\\", max_cardinality, [int, float]), (\\\"h\\\", h, [int,\",\n \"self.transformations = [elem for elem in copy_trans] raise QueryError(\\\"{}\\\\nAn Error\",\n \"already computed aggregations to gain in performance. The catalog will\",\n \"result[i][2] = None avg = \\\"DECODE({}, {}, NULL)\\\".format( by[0], \\\",\",\n \"WHERE {} > {})\\\".format( self.parent.__genSQL__(), self.alias, self.alias, p_alpha, self.alias, self.alias,\",\n \"Creates a copy of the vColumn. \\\"\\\"\\\" check_types([(\\\"new_name\\\", new_name, [str])])\",\n \"apply_fun(self, func: str, x: float = 2): \\\"\\\"\\\" --------------------------------------------------------------------------- Applies\",\n \"= \\\"WITH vdf_table AS (SELECT * FROM {}) {}\\\".format( self.parent.__genSQL__(),\",\n \"(or approximate quantile). See Also -------- vDataFrame.aggregate : Computes 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,\",\n \"of type date like. Optimized h will be computed if\",\n \"FROM {}{} OFFSET {}{}) VERTICAPY_SUBTABLE\\\".format( self.alias, self.parent.__genSQL__(), self.parent.__get_last_order_by__(), index_start, limit,\",\n \"{} THEN {} \\\".format(\\\"{}\\\", lower, lower) if (isinstance(lower, (float, int)))\",\n \"aggregation. Parameters ---------- by: str, optional vColumn to use to\",\n \"method to use to discretize the vColumn. auto : Uses\",\n \"to the vColumn. \\\"\\\"\\\" check_types( [ ( \\\"func\\\", func, [\",\n \"Looks if some specific records are in the vColumn and\",\n \"or of type date like. Optimized h will be computed\",\n \"FROM (SELECT {}, COUNT(*) AS _verticapy_cnt_ FROM {}{}GROUP BY {}\",\n \"# # VerticaPy aims to do all of the above.\",\n \"on an aggregation. Parameters ---------- method: str, optional The method\",\n \"Returns the transformation instead of the vDataFrame parent and do\",\n \"mean encoding of a response. \\\"\\\"\\\" if self.category() in [\\\"date\\\",\",\n \"name = quote_ident(name.replace('\\\"', \\\"_\\\")) assert name.replace('\\\"', \\\"\\\"), EmptyParameter( \\\"The parameter\",\n \"isinstance(index, int): cast = \\\"::float\\\" if self.category() == \\\"float\\\" else\",\n \"bool, optimal If set to True, the method will return\",\n \"computed) ax: Matplotlib axes object, optional The axes to plot\",\n \"# _____________ / / # \\\\ / / / #\",\n \".transpose() .values[self.alias] ) self.parent.filter( \\\"({} BETWEEN {} AND {})\\\".format(self.alias, p_alpha,\",\n \"elif method == \\\"minmax\\\": self.catalog[elem] = (sauv[elem] - sauv[\\\"min\\\"]) /\",\n \"= 6, h: float = 0, pie_type: str = \\\"auto\\\",\",\n \"False, ax=None, **style_kwds, ): \\\"\\\"\\\" --------------------------------------------------------------------------- Draws the Time Series\",\n \"[str, datetime.datetime, datetime.date, int, float], ), ( \\\"end_date\\\", end_date, [str,\",\n \"'same_width' for numerical vColumns, cast the other types to varchar.\",\n \"optional Value to use to impute the vColumn. method: dict,\",\n \"self.catalog[elem] = sauv[elem] return self.parent # ---# def geo_plot(self, *args,\",\n \"the Robust Z-Score (median and mad). (x - median) /\",\n \"in (\\\"None\\\", None)) else \\\" WHERE {} = '{}'\\\".format( bin_spatial_to_str(self.category(),\",\n \"# ---# def mad(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using\",\n \"utilities.tablesample. See Also -------- vDataFrame[].nlargest : Returns the n largest\",\n \"\\\"{}({})\\\".format(func.upper(), \\\"{}\\\") else: expr = \\\"{}({}, {})\\\".format(func.upper(), \\\"{}\\\", x) return\",\n \".replace(\\\"'\\\", \\\"_\\\") ) expr = \\\"DECODE({}, '{}', 1, 0)\\\".format( \\\"{}\\\",\",\n \"returns the new vDataFrame of the search. Parameters ---------- val:\",\n \": Average. median : median. mode : mode (most occurent\",\n \"model.fit(tmp_view_name, [self.alias], response) query = [ \\\"(SELECT READ_TREE(USING PARAMETERS model_name\",\n \"Aggregates the vColumn using 'kurtosis'. Returns ------- float kurtosis See\",\n \"at risk dtype : vColumn type iqr : interquartile range\",\n \"AND {} THEN '[{};{}]' \\\".format( \\\"{}\\\", result[i - 1], result[i],\",\n \"\\\"top\\\") if pre_comp != \\\"VERTICAPY_NOT_PRECOMPUTED\\\": if not (dropna) and (pre_comp\",\n \"executeSQL( \\\"SELECT {}, {} FROM {} LIMIT 1\\\".format( cmax, cmin,\",\n \"self.min() table = \\\"(SELECT DATEDIFF('second', '{}'::timestamp, {}) AS {} FROM\",\n \"+= [sum(result[\\\"non_events\\\"])] result.values[\\\"events\\\"] += [sum(result[\\\"events\\\"])] result.values[\\\"pt_non_events\\\"] += [\\\"\\\"] result.values[\\\"pt_events\\\"] +=\",\n \": product range : difference between the max and the\",\n \"result[0][0] if not (dropna): n = \\\"\\\" if (n ==\",\n \"to order the data. The vColumn type must be date\",\n \"apply the function: x -> x^2 + 2 use \\\"POWER({},\",\n \"using 'sum'. Returns ------- float sum See Also -------- vDataFrame.aggregate\",\n \"null !\\\".format( self.alias ) warnings.warn(warning_message, Warning) return self elif method\",\n \"---# def abs(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Applies the absolute value function\",\n \"of the first element (Constant Interpolation). mean : Average. median\",\n \"of: self.parent.are_namecols_in(of) of = self.parent.format_colnames(of) from verticapy.plot import bar return\",\n \"express or implied. # See the License for the specific\",\n \"vColumn_075, vColumn_max = ( result[0], result[3], result[4], result[6], result[7], )\",\n \"FROM {}) {}\\\".format( self.parent.__genSQL__(), query ) query_result = executeSQL( query=query,\",\n \"---# def sem(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using 'sem'\",\n \"{}, \\\"regr_avgy\\\": {}, \\\"regr_count\\\": {}, \\\"regr_intercept\\\": {}, \\\"regr_r2\\\": {}, \\\"regr_slope\\\":\",\n \"the numerical and Mode for the categorical vColumns. bfill :\",\n \"forbidden !\\\") return self.apply(func=\\\"{} / ({})\\\".format(\\\"{}\\\", x)) # ---# def\",\n \"series rule. \\\"\\\"\\\" return self.apply(func=\\\"DATE_PART('{}', {})\\\".format(field, \\\"{}\\\")) # ---# def\",\n \"if h > 0.01: h = round(h, 2) elif h\",\n \"self.alias) query = \\\"SELECT {} AS {}, {} AS ord,\",\n \"--------------------------------------------------------------------------- Draws the range plot of the vColumn. The aggregations\",\n \": Computes the vDataFrame input aggregations. \\\"\\\"\\\" return self.aggregate([\\\"sem\\\"]).values[self.alias][0] #\",\n \"transformations: list = [], parent=None, catalog: dict = {} ):\",\n \"filled.\\\".format( total, self.alias, conj, ) ) else: if verticapy.options[\\\"print_info\\\"]: print(\\\"Nothing\",\n \"PARAMETERS percentile = 0.75) AS 'approx_75%', APPROXIMATE_PERCENTILE ({3}{4} USING PARAMETERS\",\n \"------- float/str median See Also -------- vDataFrame.aggregate : Computes the\",\n \": Normalization using the Z-Score (avg and std). (x -\",\n \"the vColumn records. The vColumn will be transformed. Parameters ----------\",\n \") ) else: for k in range(max_floor): self.transformations += [(\\\"{}\\\",\",\n \"= (\\\"{} || ''\\\", \\\"varchar\\\", \\\"text\\\") if (self.isnum() and method\",\n \") warnings.warn(warning_message, Warning) return self.parent if isinstance(val, str): val =\",\n \"{} IS NOT NULL ORDER BY {} ASC LIMIT {}\\\".format(\",\n \"\\\"\\\"\\\" check_types( [ (\\\"breaks\\\", breaks, [list]), (\\\"labels\\\", labels, [list]), (\\\"include_lowest\\\",\",\n \"\\\"auto\\\", max_cardinality: int = 6, numcol: str = \\\"\\\" ):\",\n \"the vDataFrame input aggregations. \\\"\\\"\\\" return self.aggregate([\\\"aad\\\"]).values[self.alias][0] # ---# def\",\n \"sine sinh : hyperbolic sine sqrt : arithmetic square root\",\n \"breaks: list, labels: list = [], include_lowest: bool = True,\",\n \"gen_colors from matplotlib.lines import Line2D colors = gen_colors() if not\",\n \"ax=None, **style_kwds, ): \\\"\\\"\\\" --------------------------------------------------------------------------- Draws the Time Series of\",\n \"__ ______ ______ __ __ __ __ __ __ __\",\n \"idx == 0: op1, close_l = \\\"<\\\", \\\"]\\\" if labels:\",\n \"the parameter 'x' will represent the number of seconds, otherwise\",\n \"str): pie_type = pie_type.lower() check_types( [ (\\\"method\\\", method, [str]), (\\\"of\\\",\",\n \"# ---# def add_copy(self, name: str): \\\"\\\"\\\" --------------------------------------------------------------------------- Adds a\",\n \"\\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using 'kurtosis'. Returns ------- float\",\n \"# ---# def mean_encode(self, response: str): \\\"\\\"\\\" --------------------------------------------------------------------------- Encodes the\",\n \"applying the func 'x -> {}' to '{}'\\\".format( e, func.replace(\\\"{}\\\",\",\n \"OR events = 0 THEN 0 ELSE (pt_non_events - pt_events)\",\n \"title=\\\"Computing the different aggregations.\\\", method=\\\"fetchall\\\", ) for idx, elem in\",\n \"Normalizes the input vColumns using the input method. Parameters ----------\",\n \"USING PARAMETERS percentile = 0.25) AS Q1, APPROXIMATE_PERCENTILE({} USING PARAMETERS\",\n \"({})\\\".format(\\\"{}\\\", x)) # ---# def drop(self, add_history: bool = True):\",\n \"**kwargs Any optional parameter to pass to the geopandas plot\",\n \"MONTH / QUARTER / SECOND / TIME ZONE / TIMEZONE_HOUR\",\n \"self.nunique(True) > 6) else \\\"mode\\\" total = self.count() if (method\",\n \"and 1 (1 meaning global outlier). \\\"\\\"\\\" if isinstance(method, str):\",\n \"higher than the upper bound to the upper bound itself.\",\n \"float skewness See Also -------- vDataFrame.aggregate : Computes the vDataFrame\",\n \"- 1] (n being the vColumn cardinality). Returns ------- vDataFrame\",\n \"SQL code generation will be slower if the vDataFrame has\",\n \"ParameterError( \\\"The parameter 'numcol' must be a vDataFrame column if\",\n \"to_replace: str, value: str = \\\"\\\"): \\\"\\\"\\\" --------------------------------------------------------------------------- Replaces the\",\n \"str vColumn category. See Also -------- vDataFrame[].ctype : Returns the\",\n \"NULL\\\".format(self.alias)) return self.parent # ---# def fill_outliers( self, method: str\",\n \"{} AS {}, {} AS verticapy_agg FROM {} WHERE {}\",\n \"float]), (\\\"nbins\\\", nbins, [int, float]), ] ) if of: self.parent.are_namecols_in(of)\",\n \"(sauv[elem] - sauv[\\\"mean\\\"]) / sauv[ \\\"std\\\" ] elif method ==\",\n \"vDataFrame. \\\"\\\"\\\" check_types([(\\\"add_history\\\", add_history, [bool])]) try: parent = self.parent force_columns\",\n \"self.catalog[\\\"percent\\\"] = 100 self.parent.__add_to_history__( \\\"[Label Encoding]: Label Encoding was applied\",\n \"of the vColumn {} named {} was added to the\",\n \"== len(labels) + 1 or not (labels), ParameterError( \\\"Length of\",\n \"parent=self.parent, transformations=transformations, catalog={ \\\"min\\\": 0, \\\"max\\\": 1, \\\"count\\\": self.parent.shape()[0], \\\"percent\\\":\",\n \"def mad(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using 'mad' (median\",\n \"(float, int))) else \\\"\\\" ) func = \\\"(CASE {}{}ELSE {}\",\n \"= {self.alias: val} return self.parent.isin(val) # ---# def isnum(self): \\\"\\\"\\\"\",\n \") ] elif method == \\\"robust_zscore\\\": if n > 0:\",\n \"column if the method is 'cat_stats'\\\" ) distinct_count, is_numeric, is_date\",\n \"\\\".join(by) ), ) else: avg, stddev = ( \\\"AVG({}) OVER\",\n \") custom_lines += [ Line2D( [0], [0], color=updated_dict(param, style_kwds, idx)[\\\"color\\\"],\",\n \"self.parent.are_namecols_in([elem for elem in order_by] + by) by = self.parent.format_colnames(by)\",\n \"response column must be numerical to use a mean encoding\\\"\",\n \"{column} AND {column} {op2} '{second_elem}' THEN '{label}'\\\" ] expr =\",\n \"str_contains(self, pat: str): \\\"\\\"\\\" --------------------------------------------------------------------------- Verifies if the regular expression\",\n \"(), PERCENTILE_CONT(1 - {}) WITHIN GROUP (ORDER BY {}) OVER\",\n \"/ # ______ / / # \\\\ / / /\",\n \"1.0, kernel: str = \\\"gaussian\\\", nbins: int = 200, xlim:\",\n \"if \\\"agg\\\" not in kwargs: query = \\\"SELECT {} AS\",\n \"transforms the vColumn using a time series rule. Parameters ----------\",\n \"def add_copy(self, name: str): \\\"\\\"\\\" --------------------------------------------------------------------------- Adds a copy vColumn\",\n \"bound to the upper bound itself. Parameters ---------- lower: float,\",\n \"method = method.lower() if self.isnum() and method == \\\"smart\\\": schema\",\n \"not (result) else result[0][0] if not (dropna): n = \\\"\\\"\",\n \"variance Other aggregations could work if it is part of\",\n \"vDataFrame. \\\"\\\"\\\" if isinstance(val, str) or not (isinstance(val, Iterable)): val\",\n \"bijection from the different categories to [0, n - 1]\",\n \"(No h will be picked or computed) h: float, optional\",\n \"by if method in [\\\"ffill\\\", \\\"pad\\\", \\\"bfill\\\", \\\"backfill\\\"]: all_partition +=\",\n \"0.05, ): \\\"\\\"\\\" --------------------------------------------------------------------------- Fills the vColumns outliers using the\",\n \"{}) / {}({})\\\".format( self.alias, avg, \\\"NULLIFZERO\\\" if (nullifzero) else \\\"\\\",\",\n \"val: list List of the different records. For example, to\",\n \"FROM (SELECT {} AS {}, {} AS verticapy_agg FROM {}\",\n \"+ 1) query = \\\"WITH vdf_table AS (SELECT * FROM\",\n \"\\\"end_date\\\", end_date, [str, datetime.datetime, datetime.date, int, float], ), (\\\"plot_median\\\", plot_median,\",\n \"Warning) return self elif method == \\\"minmax\\\": if n ==\",\n \"STDDEV({}) FROM {} GROUP BY {}\\\".format( by[0], self.alias, self.alias, self.parent.__genSQL__(),\",\n \"represents Q1. approx: bool, optional If set to True, the\",\n \"if method.lower() == \\\"sturges\\\": best_h = sturges elif method.lower() in\",\n \"self.transformations += [(expr, \\\"int\\\", \\\"int\\\")] self.parent.__update_catalog__(erase=True, columns=[self.alias]) self.catalog[\\\"count\\\"] = self.parent.shape()[0]\",\n \"(self.isnum() and self.nunique(True) > 6) else \\\"mode\\\" total = self.count()\",\n \"IS NULL\\\".format(self.alias) if (category in (\\\"None\\\", None)) else \\\" WHERE\",\n \": Returns the head of the vColumn. \\\"\\\"\\\" return self.iloc(limit=limit,\",\n \"xmin, xmax = xlim custom_lines = [] columns = self.parent[by].distinct()\",\n \"!= \\\"numerical\\\")) or not (is_numeric) or (method == \\\"categorical\\\") ):\",\n \"2 in case of discretization using the method 'topk'\\\" )\",\n \"the same number of elements. same_width : Computes regular width\",\n \"i in range(1, n): trans += \\\"WHEN {} BETWEEN {}\",\n \"index, self.alias: result}) for elem in values: for i in\",\n \"): \\\"\\\"\\\" --------------------------------------------------------------------------- Fills the vColumns outliers using the input\",\n \") method = method.lower() self.parent.are_namecols_in(by) by = self.parent.format_colnames(by) nullifzero, n\",\n \"getattr(self, index) # ---# def __len__(self): return int(self.count()) # ---#\",\n \"their distributions as percents. Parameters ---------- k: int, optional Number\",\n \"1] ... ELSE argv[n] END Returns ------- vDataFrame self.parent See\",\n \"AS {}, COUNT(*) AS _verticapy_cnt_, 100 * COUNT(*) / {}\",\n \"consider when drawing the box plot. The other categories will\",\n \"\\\\____ \\\\ \\\\ \\\\_\\\\ \\\\ \\\\ \\\\ \\\\-./\\\\ \\\\ \\\\\",\n \"bool, optional Returns the transformation instead of the vDataFrame parent\",\n \"y, y, self.parent.__genSQL__(), ) query = \\\"SELECT {}, MIN(ord) AS\",\n \"the 'alpha' parameter. alpha: float, optional Number representing the outliers\",\n \"# ---# def head(self, limit: int = 5): \\\"\\\"\\\" ---------------------------------------------------------------------------\",\n \"FROM {} WHERE {} IS NOT NULL GROUP BY 1)\",\n \"# \\\\ / # \\\\ / # \\\\/ # _\",\n \"AS (SELECT * FROM {}) {}\\\".format( self.parent.__genSQL__(), \\\" UNION ALL\",\n \"be dropped. Returns ------- vDataFrame self.parent See Also -------- vDataFrame.fill_outliers\",\n \"self.parent See Also -------- vDataFrame[].decode : Encodes the vColumn using\",\n \"utilities.tablesample. See Also -------- vDataFrame[].head : Returns the head of\",\n \"'breaks' must be greater or equal to 2.\\\" ) assert\",\n \"if of: self.parent.are_namecols_in(of) of = self.parent.format_colnames(of) from verticapy.plot import bar\",\n \"-------- vDataFrame.isin : Looks if some specific records are in\",\n \"200, xlim: tuple = None, ax=None, **style_kwds, ): \\\"\\\"\\\" ---------------------------------------------------------------------------\",\n \"a list of at least one element to use to\",\n \"ctype # ---# def date_part(self, field: str): \\\"\\\"\\\" --------------------------------------------------------------------------- Extracts\",\n \"elem in self.transformations] total = self.count() if method not in\",\n \"def iv_woe(self, y: str, nbins: int = 10): \\\"\\\"\\\" ---------------------------------------------------------------------------\",\n \"(date, datetime, timestamp...) or numerical. q: tuple, optional Tuple including\",\n \"\\\"mod\\\", \\\"pow\\\", \\\"round\\\"): expr = \\\"{}({})\\\".format(func.upper(), \\\"{}\\\") else: expr =\",\n \"# ---# def __len__(self): return int(self.count()) # ---# def __nonzero__(self):\",\n \"import gen_cmap kwargs[\\\"cmap\\\"] = gen_cmap()[0] else: if not (\\\"color\\\" in\",\n \"\\\"\\\"\\\" check_types( [ (\\\"prefix\\\", prefix, [str]), (\\\"prefix_sep\\\", prefix_sep, [str]), (\\\"drop_first\\\",\",\n \"matches in each of the vColumn record by an input\",\n \"[ \\\"'{}'\\\".format(str(elem).replace(\\\"'\\\", \\\"''\\\")) for elem in distinct ] ), bin_spatial_to_str(self.category()),\",\n \"\\\\ \\\\_\\\\ \\\\ \\\\ \\\\ \\\\-./\\\\ \\\\ \\\\ \\\\ \\\\-.\",\n \"whole number ln : natural logarithm log : logarithm log10\",\n \"(\\\"method\\\", method, [\\\"auto\\\", \\\"numerical\\\", \\\"categorical\\\", \\\"cat_stats\\\"]), (\\\"max_cardinality\\\", max_cardinality, [int, float]),\",\n \"of values used to cut the vColumn. labels: list, optional\",\n \"method=\\\"fetchall\\\", ) result = [elem[0] for elem in result] except:\",\n \"# ---# def isdate(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns True if the\",\n \"elif method in (\\\"mean\\\", \\\"avg\\\", \\\"median\\\"): fun = \\\"MEDIAN\\\" if\",\n \"var See Also -------- vDataFrame.aggregate : Computes the vDataFrame input\",\n \"Slice size. unit: str, optional Slice size unit. For example,\",\n \"how often they occur, and other statistical information. Parameters ----------\",\n \"copy_name: str = \\\"\\\"): \\\"\\\"\\\" --------------------------------------------------------------------------- Applies a function to\",\n \"max_floor ) except: pass max_floor -= len(self.transformations) if copy_name: self.add_copy(name=copy_name)\",\n \"\\\"null\\\", \\\"mean\\\"]), (\\\"alpha\\\", alpha, [int, float]), (\\\"use_threshold\\\", use_threshold, [bool]), (\\\"threshold\\\",\",\n \"--------------------------------------------------------------------------- Draws the bar chart of the vColumn based on\",\n \"[list]), ] ) if by: self.parent.are_namecols_in(by) by = self.parent.format_colnames(by) from\",\n \"dummy to avoid the creation of correlated features. use_numbers_as_suffix: bool,\",\n \"result[\\\"std\\\"][0] + result[\\\"avg\\\"][0], ) else: query = \\\"SELECT PERCENTILE_CONT({}) WITHIN\",\n \"= self.parent.format_colnames(by) columns = [self.alias, by] else: columns = [self.alias]\",\n \"func=\\\"REGEXP_REPLACE({}, '{}', '{}')\\\".format( \\\"{}\\\", to_replace.replace(\\\"'\\\", \\\"''\\\"), value.replace(\\\"'\\\", \\\"''\\\") ) )\",\n \"+= [(\\\"{}\\\", self.ctype(), self.category())] self.transformations += [(new_column, ctype, category)] try:\",\n \"SQL used to transform the vColumn. The function variable must\",\n \"if the response is numerical (except ints and bools), a\",\n \"vColumns to use to sort the data when using TS\",\n \"# ---# def str_count(self, pat: str): \\\"\\\"\\\" --------------------------------------------------------------------------- Computes the\",\n \"label = labels[idx] else: label = f\\\"{close_l}{first_elem};{second_elem}{close_r}\\\" conditions += [\",\n \"--------------------------------------------------------------------------- Fills the vColumns outliers using the input method. Parameters\",\n \"Also -------- vDataFrame.donut : Draws the donut chart of the\",\n \"pat: str): \\\"\\\"\\\" --------------------------------------------------------------------------- Computes the number of matches for\",\n \"axes to plot on. **style_kwds Any optional parameter to pass\",\n \"expected store usage. \\\"\\\"\\\" pre_comp = self.parent.__get_catalog_value__(self.alias, \\\"store_usage\\\") if pre_comp\",\n \"response, [str])]) self.parent.are_namecols_in(response) response = self.parent.format_colnames(response) assert self.parent[response].isnum(), TypeError( \\\"The\",\n \"100 * COUNT(*) / {} AS percent FROM {}{} GROUP\",\n \"\\\"mode\\\", \\\"0ifnull\\\", \\\"mean\\\", \\\"avg\\\", \\\"median\\\", \\\"ffill\\\", \\\"pad\\\", \\\"bfill\\\", \\\"backfill\\\", ],\",\n \"see utilities.tablesample. See Also -------- vDataFrame.aggregate : Computes the vDataFrame\",\n \"sum See Also -------- vDataFrame.aggregate : Computes the vDataFrame input\",\n \": Percentage of the distribution. mean : Average of the\",\n \"**kwargs) # ---# def get_dummies( self, prefix: str = \\\"\\\",\",\n \"self.parent.are_namecols_in(of) of = self.parent.format_colnames(of) from verticapy.plot import pie return pie(\",\n \"iv_woe.\\\".format(y) ) response_cat = self.parent[y].distinct() response_cat.sort() assert response_cat == [0,\",\n \"The idea is simple: instead of moving # data around\",\n \"elements. density : Percentage of the distribution. mean : Average\",\n \"keep after the comma. Returns ------- vDataFrame self.parent See Also\",\n \"import range_curve_vdf return range_curve_vdf( self, ts, q, start_date, end_date, plot_median,\",\n \"+ result, } if ((is_date) and not (method == \\\"categorical\\\"))\",\n \"on an aggregation. Parameters ---------- by: str, optional vColumn to\",\n \"= (sauv[elem] - sauv[\\\"mean\\\"]) / sauv[ \\\"std\\\" ] elif method\",\n \"str_replace(self, to_replace: str, value: str = \\\"\\\"): \\\"\\\"\\\" --------------------------------------------------------------------------- Replaces\",\n \"elem[1] != None ] ), ) stddev = \\\"DECODE({}, {},\",\n \"FROM vdf_table\\\"\\\"\\\".format( category, self.alias, self.parent.shape()[0], numcol, cast, ) tmp_query +=\",\n \"new vColumn labeled with 0 and 1 (1 meaning global\",\n \"drawn. ax: Matplotlib axes object, optional The axes to plot\",\n \"will look like: even: CASE ... WHEN vColumn = argv[2\",\n \"(ex: 50% to get the median). It can also be\",\n \"(SELECT * FROM {}) {}\\\".format( self.parent.__genSQL__(), query ) query_result =\",\n \"{}, {} AS verticapy_agg FROM {} WHERE {} IS NOT\",\n \"query=query, title=\\\"Computing the optimized histogram nbins using Random Forest.\\\", method=\\\"fetchall\\\",\",\n \"str_sql): func = str(func) check_types([(\\\"func\\\", func, [str]), (\\\"copy_name\\\", copy_name, [str])])\",\n \"(\\\"max_cardinality\\\", max_cardinality, [int, float]), (\\\"h\\\", h, [int, float]), (\\\"cat_priority\\\", cat_priority,\",\n \"top1 for the mode) topk_percent : kth most occurent element\",\n \"[str]), (\\\"by\\\", by, [str]), (\\\"start_date\\\", start_date, [str, datetime.datetime, datetime.date]), (\\\"end_date\\\",\",\n \"to be used as categorical (No h will be picked\",\n \": Computes the vColumn descriptive statistics. \\\"\\\"\\\" return self.describe(method=\\\"categorical\\\", max_cardinality=k)\",\n \"brackets {}. For example to apply the function: x ->\",\n \"specified name. \\\\u26A0 Warning : SQL code generation will be\",\n \"BY {}))\\\".format( \\\"{}\\\", \\\"{}\\\", partition_by, order_by_ts ) if method in\",\n \"stddev ) else: final_transformation = [ ( \\\"({} - {})\",\n \"Deviation). Returns ------- float aad See Also -------- vDataFrame.aggregate :\",\n \") assert self.isnum() or self.isdate(), TypeError( \\\"cut only works on\",\n \"usage. See Also -------- vDataFrame.expected_store_usage : Returns the vDataFrame expected\",\n \": Computes the vDataFrame input aggregations. \\\"\\\"\\\" check_types( [ (\\\"method\\\",\",\n \"chart. auto : Regular pie chart. donut : Donut chart.\",\n \"\\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using 'min' (Minimum). Returns -------\",\n \"PERCENTILE_CONT(1 - {}) WITHIN GROUP (ORDER BY {}) OVER ()\",\n \"Aggregates the vColumn using 'aad' (Average Absolute Deviation). Returns -------\",\n \"the function has two arguments (example, power or mod), 'x'\",\n \"2 to be used as categorical (No h will be\",\n \"vColumn is boolean. See Also -------- vDataFrame[].isdate : Returns True\",\n \"max_cardinality, [int, float]), (\\\"numcol\\\", numcol, [str]), ] ) method =\",\n \"of the vColumn. \\\"\\\"\\\" check_types([(\\\"new_name\\\", new_name, [str])]) old_name = quote_ident(self.alias)\",\n \"{})\\\".format(len(distinct_elements)) self.transformations += [(expr, \\\"int\\\", \\\"int\\\")] self.parent.__update_catalog__(erase=True, columns=[self.alias]) self.catalog[\\\"count\\\"] =\",\n \"auto : Regular pie chart. donut : Donut chart. rose\",\n \"if the vColumn category is date. \\\"\\\"\\\" return self.category() in\",\n \"verticapy.stats as st return self.apply(func=st.decode(str_sql(\\\"{}\\\"), *argv)) # ---# def density(\",\n \": arithmetic sign sin : trigonometric sine sinh : hyperbolic\",\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\",\n \"max_floor: max_floor = len(self.parent[elem].transformations) max_floor -= len(self.transformations) for k in\",\n \"'{}') > 0\\\".format(\\\"{}\\\", pat.replace(\\\"'\\\", \\\"''\\\")) ) # ---# def str_count(self,\",\n \"sauv: self.catalog[\\\"count\\\"] = sauv[\\\"count\\\"] self.catalog[\\\"percent\\\"] = ( 100 * sauv[\\\"count\\\"]\",\n \"n, [int, float])]) return self.apply(func=\\\"ROUND({}, {})\\\".format(\\\"{}\\\", n)) # ---# def\",\n \"License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by\",\n \"Number of elements to display. offset: int, optional Number of\",\n \"to 2 in case of discretization using the method 'topk'\\\"\",\n \"min : minimum mode : most occurent element percent :\",\n \"\\\\ / _ __|_. _ _ |_) # \\\\/ (/_|\",\n \"mode) topk_percent : kth most occurent element density unique :\",\n \"= self.count() nb = int(float(count / int(nbins))) assert nb !=\",\n \"\\\\u26A0 Warning : SQL code generation will be slower if\",\n \"[list]), (\\\"h\\\", h, [list, float, int]), ] ) if by:\",\n \"computed if the parameter is empty or invalid. max_cardinality: int,\",\n \") cast = \\\"::int\\\" if (self.parent[numcol].isbool()) else \\\"\\\" query, cat\",\n \"vDataFrame[].slice : Slices the vColumn using a time series rule.\",\n \"the input number of digits after the comma. Parameters ----------\",\n \"), \\\"float\\\", \\\"float\\\", ) ] elif method == \\\"robust_zscore\\\": if\",\n \"applied to the vColumn {}\\\\n{} feature{}created: {}\\\".format( self.alias, len(all_new_features), conj,\",\n \"by: str = \\\"\\\", h: float = 0, max_cardinality: int\",\n \"result[\\\"std\\\"][0] + result[\\\"avg\\\"][0], threshold * result[\\\"std\\\"][0] + result[\\\"avg\\\"][0], ) else:\",\n \"END odd : CASE ... WHEN vColumn = argv[2 *\",\n \"\\\"winsorize\\\": self.clip(lower=p_alpha, upper=p_1_alpha) elif method == \\\"null\\\": self.apply( func=\\\"(CASE WHEN\",\n \"Also -------- vDataFrame.bar : Draws the Bar Chart of the\",\n \"to draw the Plot. start_date: str / date, optional Input\",\n \"must be binary to use iv_woe.\\\".format(y) ) response_cat = self.parent[y].distinct()\",\n \"-------- vDataFrame.plot : Draws the time series. \\\"\\\"\\\" check_types( [\",\n \"def tail(self, limit: int = 5): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns the\",\n \"input quantiles. Parameters ---------- ts: str TS (Time Series) vColumn\",\n \"avg, stddev, self.parent.__genSQL__() ), print_time_sql=False, ) except: avg, stddev =\",\n \"list = [], order_by: list = [], ): \\\"\\\"\\\" ---------------------------------------------------------------------------\",\n \"vColumn cardinality). Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].decode\",\n \"/ float / text / binary / spatial / uuid\",\n \"smallest elements.\\\".format(n, self.alias) return to_tablesample(query, title=title) # ---# def numh(self,\",\n \"True, the Median will be drawn. ax: Matplotlib axes object,\",\n \"{}, {} FROM {} LIMIT 1\\\".format( cmax, cmin, self.parent.__genSQL__() ),\",\n \"x: float Input number. Returns ------- vDataFrame self.parent See Also\",\n \"(ORDER BY {}) OVER () FROM {} LIMIT 1\\\".format( alpha,\",\n \"if return_trans: return \\\"({} - {}) / ({})\\\".format(self.alias, med, mad)\",\n \"use to aggregate the data. count : Number of elements.\",\n \"== 1) and (self.parent[by[0]].nunique() < 50): try: result = executeSQL(\",\n \"\\\\/ (/_| | |(_(_|| \\\\/ # / # VerticaPy is\",\n \"new_column = \\\"COALESCE({}, DECODE({}, {}, NULL))\\\".format( \\\"{}\\\", by[0], \\\", \\\".join(\",\n \"nbins, [int])]) self.parent.are_namecols_in(y) y = self.parent.format_colnames(y) assert self.parent[y].nunique() == 2,\",\n \") start_or_end = \\\"START\\\" if (start) else \\\"END\\\" return self.apply(\",\n \"), ] ax.set_title(\\\"KernelDensity\\\") ax.legend( custom_lines, columns, title=by, loc=\\\"center left\\\", bbox_to_anchor=[1,\",\n \"mode (only missing values).\\\\nNothing was filled.\\\".format( self.alias ) warnings.warn(warning_message, Warning)\",\n \"from the vColumn. \\\"\\\"\\\" check_types( [ (\\\"length\\\", length, [int, float]),\",\n \"offset: int, optional Number of elements to skip. Returns -------\",\n \"or invalid. max_cardinality: int/tuple, optional Maximum number of distinct elements\",\n \"Divides the vColumn by the input element. Parameters ---------- x:\",\n \"the following list: [\\\"Fouad\\\", \\\"Badr\\\"] Returns ------- vDataFrame The vDataFrame\",\n \"= \\\"::int\\\" if (self.parent[numcol].isbool()) else \\\"\\\" query, cat = [],\",\n \"[ (\\\"length\\\", length, [int, float]), (\\\"unit\\\", unit, [str]), (\\\"start\\\", start,\",\n \"min sem : standard error of the mean skewness :\",\n \": Computes the vDataFrame input aggregations. \\\"\\\"\\\" return self.aggregate([\\\"avg\\\"]).values[self.alias][0] mean\",\n \"str) or not (isinstance(cat_priority, Iterable)): cat_priority = [cat_priority] check_types( [\",\n \"\\\"NULL\\\", elem[1] if elem[1] != None else \\\"NULL\\\", ) for\",\n \"the vColumn. vDataFrame.outliers : Adds a new vColumn labeled with\",\n \"= vColumn( name, parent=self.parent, transformations=transformations, catalog={ \\\"min\\\": 0, \\\"max\\\": 1,\",\n \"------- ax Matplotlib axes object See Also -------- vDataFrame.donut :\",\n \"'approx_50%', APPROXIMATE_PERCENTILE ({3}{4} USING PARAMETERS percentile = 0.75) AS 'approx_75%',\",\n \"--------------------------------------------------------------------------- Adds the input element to the vColumn. Parameters ----------\",\n \"Note: Dropping a vColumn can make the vDataFrame \\\"heavier\\\" if\",\n \"return self.apply(func=\\\"TIMESTAMPADD(SECOND, {}, {})\\\".format(x, \\\"{}\\\")) else: return self.apply(func=\\\"{} + ({})\\\".format(\\\"{}\\\",\",\n \"+ result[\\\"avg\\\"][0], ) else: query = \\\"SELECT PERCENTILE_CONT({}) WITHIN GROUP\",\n \"== \\\"0ifnull\\\": category, ctype = \\\"int\\\", \\\"bool\\\" else: category, ctype\",\n \"self.alias, query, ) title = \\\"Computing WOE & IV of\",\n \"column in enumerate(columns): param = {\\\"color\\\": colors[idx % len(colors)]} ax\",\n \"\\\"({} - {}) / {}({} - {})\\\".format( \\\"{}\\\", cmin, \\\"NULLIFZERO\\\"\",\n \"str Regular expression to replace. value: str, optional New value.\",\n \"Parameters ---------- prefix: str, optional Prefix of the dummies. prefix_sep:\",\n \"sturges elif method.lower() in (\\\"freedman_diaconis\\\", \\\"fd\\\"): best_h = fd else:\",\n \"(len(by) == 1) and (self.parent[by[0]].nunique() < 50): try: if fun\",\n \"{}{} GROUP BY {} ORDER BY _verticapy_cnt_ DESC {}\\\".format( bin_spatial_to_str(self.category(),\",\n \"kernel = kernel.lower() from verticapy.learn.neighbors import KernelDensity schema = verticapy.options[\\\"temp_schema\\\"]\",\n \"def apply(self, func: str, copy_name: str = \\\"\\\"): \\\"\\\"\\\" ---------------------------------------------------------------------------\",\n \"new categories. If empty, names will be generated. include_lowest: bool,\",\n \"THEN '[{};{}]' \\\".format( \\\"{}\\\", result[i - 1], result[i], result[i -\",\n \"------- bool True if the vColumn category is date. See\",\n \"''\\\", \\\"varchar\\\", \\\"text\\\") if (self.isnum() and method == \\\"same_freq\\\") or\",\n \"if func not in (\\\"log\\\", \\\"mod\\\", \\\"pow\\\", \\\"round\\\"): expr =\",\n \"{} \\\".format(\\\"{}\\\", upper, upper) if (isinstance(upper, (float, int))) else \\\"\\\"\",\n \"Prefix delimitor of the dummies. drop_first: bool, optional Drops the\",\n \"== \\\"is_numeric\\\" ): self.parent.__update_catalog__({\\\"index\\\": index, self.alias: result}) for elem in\",\n \"verticapy.plot import gen_colors kwargs[\\\"color\\\"] = gen_colors()[0] if not (\\\"legend\\\" in\",\n \"{} LIMIT 1\\\".format( new_column.format(self.alias), self.parent.__genSQL__() ), print_time_sql=False, ) except: new_column\",\n \"[\\\"sturges\\\", \\\"freedman_diaconis\\\", \\\"fd\\\", \\\"auto\\\"])] ) method = method.lower() if method\",\n \"20, \\\"max_depth\\\": 10} to train a Random Forest with 20\",\n \"parent = self.drop(add_history=False) parent.__add_to_history__( \\\"[Rename]: The vColumn {} was renamed\",\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,\",\n \"({})\\\".format(self.alias, med, mad) else: final_transformation = [ ( \\\"({} -\",\n \"* result[\\\"std\\\"][0] + result[\\\"avg\\\"][0], threshold * result[\\\"std\\\"][0] + result[\\\"avg\\\"][0], )\",\n \"**style_kwds) # ---# def iloc(self, limit: int = 5, offset:\",\n \"be used as categorical. The less frequent elements will be\",\n \"See Also -------- vDataFrame[].head : Returns the head of the\",\n \"[bool]), (\\\"threshold\\\", threshold, [int, float]), ] ) if use_threshold: result\",\n \"for the median) prod : product range : difference between\",\n \"(\\\"return_enum_trans\\\", return_enum_trans, [bool]), (\\\"h\\\", h, [int, float]), (\\\"response\\\", response, [str]),\",\n \"] ) if use_threshold: result = self.aggregate(func=[\\\"std\\\", \\\"avg\\\"]).transpose().values self.parent.filter( \\\"ABS({}\",\n \"result = self.aggregate(func=[\\\"std\\\", \\\"avg\\\"]).transpose().values self.parent.filter( \\\"ABS({} - {}) / {}\",\n \"if not (\\\"figsize\\\" in kwargs): kwargs[\\\"figsize\\\"] = (14, 10) return\",\n \"method. Parameters ---------- method: str, optional Method to use to\",\n \"= \\\"SELECT {} AS index, non_events, events, pt_non_events, pt_events, CASE\",\n \"the alias of one of the dummies ({name}).\\\\n\\\" \\\"It can\",\n \"{}\\\".format( self.parent.__genSQL__(), query ) query_result = executeSQL( query=query, title=\\\"Computing the\",\n \"\\\" if verticapy.options[\\\"print_info\\\"]: print(\\\"{} element{}filled.\\\".format(total, conj)) self.parent.__add_to_history__( \\\"[Fillna]: {} {}\",\n \"to the input vColumns. vDataFrame.applymap : Applies a function to\",\n \"/ DAY / DECADE / DOQ / DOW / DOY\",\n \"\\\"\\\"\\\" check_types([(\\\"dropna\\\", dropna, [bool]), (\\\"n\\\", n, [int, float])]) if n\",\n \"\\\"\\\"\\\" check_types([(\\\"x\\\", x, [int, float])]) return self.apply(func=\\\"{} * ({})\\\".format(\\\"{}\\\", x))\",\n \"are in the vColumn. You can write the following list:\",\n \": Fills the vColumn outliers using the input method. \\\"\\\"\\\"\",\n \"be empty in case of discretization using the method 'smart'.\\\"\",\n \"the best splits when 'method' is set to 'smart'. A\",\n \"elements. \\\"\\\"\\\" if \\\"agg\\\" not in kwargs: query = \\\"SELECT\",\n \"= self.parent.format_colnames(ts) if by: self.parent.are_namecols_in(by) by = self.parent.format_colnames(by) from verticapy.plot\",\n \"unique : cardinality (count distinct) var : variance Other aggregations\",\n \"FROM {} GROUP BY {};\\\".format( by[0], fun, self.alias, self.parent.__genSQL__(), by[0]\",\n \"of the vColumn record by an input value. The vColumn\",\n \"else \\\" WHERE {} = '{}'\\\".format( bin_spatial_to_str(self.category(), self.alias), category, )\",\n \"# VerticaPy is a Python library with scikit-like functionality for\",\n \"axes object See Also -------- vDataFrame.plot : Draws the time\",\n \") ) # ---# def apply_fun(self, func: str, x: float\",\n \"WHEN vColumn = argv[2 * i] THEN argv[2 * i\",\n \"[list]), (\\\"order_by\\\", order_by, [list]), ] ) method = method.lower() self.parent.are_namecols_in([elem\",\n \"optional Number representing the outliers threshold. Values lesser than quantile(alpha)\",\n \"float])]) if self.isdate(): return self.apply(func=\\\"TIMESTAMPADD(SECOND, -({}), {})\\\".format(x, \\\"{}\\\")) else: return\",\n \"\\\"std\\\" ] elif method == \\\"minmax\\\": self.catalog[elem] = (sauv[elem] -\",\n \"query = \\\"SELECT {} FROM (SELECT {}, ROW_NUMBER() OVER (ORDER\",\n \"limit = 0 limit = \\\" LIMIT {}\\\".format(limit) else: limit\",\n \"for sublist in query_result for item in sublist] # ---#\",\n \"optional Input End Date. For example, time = '03-11-1993' will\",\n \"WHERE {} < {}) UNION ALL (SELECT AVG({}) FROM vdf_table\",\n \"name, new_vColumn) setattr(self.parent, name[1:-1], new_vColumn) self.parent._VERTICAPY_VARIABLES_[\\\"columns\\\"] += [name] self.parent.__add_to_history__( \\\"[Add\",\n \"= False, ): \\\"\\\"\\\" --------------------------------------------------------------------------- Encodes the vColumn with the\",\n \"from verticapy.plot import hist return hist(self, method, of, max_cardinality, nbins,\",\n \"agg = aggregate # ---# def apply(self, func: str, copy_name:\",\n \"== []: if fun == \\\"AVG\\\": val = self.avg() elif\",\n \"to discretize the vColumn. auto : Uses method 'same_width' for\",\n \"Clips the vColumn by transforming the values lesser than the\",\n \"= 2): \\\"\\\"\\\" --------------------------------------------------------------------------- Applies a default function to the\",\n \"self.parent # ---# def geo_plot(self, *args, **kwargs): \\\"\\\"\\\" --------------------------------------------------------------------------- Draws\",\n \"{}) {}\\\".format( self.parent.__genSQL__(), \\\" UNION ALL \\\".join(query) ) title =\",\n \"be transformed. Parameters ---------- pat: str regular expression. Returns -------\",\n \"float = 0, pie_type: str = \\\"auto\\\", ax=None, **style_kwds, ):\",\n \"return result except: model.drop() raise # ---# def describe( self,\",\n \"\\\".format(self.alias) if (dropna) else \\\" \\\" result = executeSQL( \\\"SELECT\",\n \"float vColumn memory usage (byte) See Also -------- vDataFrame.memory_usage :\",\n \": Returns the vColumn most occurent elements. \\\"\\\"\\\" if \\\"agg\\\"\",\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\",\n \"= sauv[\\\"count\\\"] self.catalog[\\\"percent\\\"] = ( 100 * sauv[\\\"count\\\"] / self.parent.shape()[0]\",\n \"empty, an optimized h will be computed. ax: Matplotlib axes\",\n \"\\\"{}\\\", h, h, \\\"{}\\\", h, h, h, floor_end ), \\\"varchar\\\",\",\n \"\\\"\\\"\\\" if self.category() in [\\\"date\\\", \\\"float\\\"]: warning_message = ( \\\"label_encode\",\n \"itself and the values higher than the upper bound to\",\n \"selecting it in the final generated SQL code. Note: Dropping\",\n \"= catalog[elem] # ---# def __getitem__(self, index): if isinstance(index, slice):\",\n \"null, 1 otherwise. expr: str, optional SQL expression. by: list,\",\n \"self.count() if (method == \\\"mode\\\") and (val == None): val\",\n \"str/float/int vColumn nth most occurent element. See Also -------- vDataFrame.aggregate\",\n \"vColumns based on an aggregation. \\\"\\\"\\\" check_types( [ (\\\"by\\\", by,\",\n \"\\\\/ # / # VerticaPy is a Python library with\",\n \"xlim: xmin = self.min() xmax = self.max() else: xmin, xmax\",\n \"self.parent[copy_name].transformations += [(func, ctype, category)] self.parent[copy_name].catalog = self.catalog self.parent.__add_to_history__( \\\"[Apply]:\",\n \"if return_trans: return \\\"({} - {}) / {}({})\\\".format( self.alias, avg,\",\n \"new category : 'Others'. cat_priority: list, optional List of the\",\n \"trans += \\\"WHEN {} BETWEEN {} AND {} THEN '[{};{}]'\",\n \"nth most occurent element. Parameters ---------- dropna: bool, optional If\",\n \"rose, ax=None, **style_kwds, ) # ---# def plot( self, ts:\",\n \"is greater than November 1993 the 3rd. area: bool, optional\",\n \"\\\"{}\\\\nError when applying the func 'x -> {}' to '{}'\\\".format(\",\n \"|_)(_|(_|| \\\\_/|_|(_||| # / # ____________ ______ # / __\",\n \"---# def isbool(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns True if the vColumn\",\n \"\\\"bfill\\\", \\\"backfill\\\"): assert order_by, ParameterError( \\\"If the method is in\",\n \"ASC LIMIT 1\\\".format( self.alias, self.alias, self.parent.__genSQL__(), where, self.alias, n ),\",\n \"cardinality is returned. By setting this parameter to False, the\",\n \"For example to apply the function: x -> x^2 +\",\n \"the absolute value of the record is greater than the\",\n \"ctype = \\\"float\\\", \\\"float\\\" elif method == \\\"0ifnull\\\": category, ctype\",\n \"self.apply(func=\\\"SUBSTR({}, {}, {})\\\".format(\\\"{}\\\", start, step)) # ---# def sub(self, x:\",\n \"[(expr, \\\"int\\\", \\\"int\\\")] self.parent.__update_catalog__(erase=True, columns=[self.alias]) self.catalog[\\\"count\\\"] = self.parent.shape()[0] self.catalog[\\\"percent\\\"] =\",\n \"plot. gaussian : Gaussian kernel. logistic : Logistic kernel. sigmoid\",\n \"range(max_floor): self.transformations += [(\\\"{}\\\", self.ctype(), self.category())] self.transformations += [ (\\\"AVG({})\",\n \"|| ''\\\", \\\"varchar\\\", \\\"text\\\") if (self.isnum() and method == \\\"same_freq\\\")\",\n \"\\\"\\\") + prefix_sep.replace('\\\"', \\\"_\\\") if not (prefix) else prefix.replace('\\\"', \\\"_\\\")\",\n \"0 for column in all_cols: try: if (quote_ident(column) in func)\",\n \"self.alias, self.alias, table ) result = executeSQL( query, title=\\\"Different aggregations\",\n \"1) and (self.parent[by[0]].nunique() < 50): try: result = executeSQL( \\\"SELECT\",\n \"nbins, h, ax=ax, **style_kwds) # ---# def iloc(self, limit: int\",\n \"product # ---# def quantile(self, x: float, approx: bool =\",\n \"APPROXIMATE_PERCENTILE ({3}{4} USING PARAMETERS percentile = 0.5) AS 'approx_50%', APPROXIMATE_PERCENTILE\",\n \"date like (date, datetime, timestamp...) or numerical. q: tuple, optional\",\n \": Logistic kernel. sigmoid : Sigmoid kernel. silverman : Silverman\",\n \"mad, med = self.aggregate([\\\"mad\\\", \\\"approx_median\\\"]).values[self.alias] mad *= 1.4826 if mad\",\n \"stddev = self.aggregate([\\\"avg\\\", \\\"std\\\"]).values[self.alias] if stddev == 0: warning_message =\",\n \"\\\"\\\"\\\" --------------------------------------------------------------------------- Returns the vColumn expected store usage (unit: b).\",\n \"See Also -------- vDataFrame[].ctype : Returns the vColumn database type.\",\n \"than the upper bound to the upper bound itself. Parameters\",\n \"sigmoid : Sigmoid kernel. silverman : Silverman kernel. nbins: int,\",\n \"vColumn will be transformed. Parameters ---------- field: str The field\",\n \"vDataFrame.applymap : Applies a function to all the vColumns. vDataFrame.eval\",\n \"elem in sauv: self.catalog[elem] = sauv[elem] return self.parent # ---#\",\n \"lp, rp = \\\"\\\", \\\"\\\" for category in cat: tmp_query\",\n \"vColumns using the input method. Parameters ---------- method: str, optional\",\n \"elem: if \\\"percent\\\" in elem: self.catalog[elem] = sauv[elem] elif elem\",\n \"using a time series rule. Parameters ---------- length: int Slice\",\n \"number of nbins used for the discretization (must be >\",\n \"generated. include_lowest: bool, optional If set to True, the lowest\",\n \"vColumn can be seen as one column of that relation.\",\n \"check_types([(\\\"limit\\\", limit, [int, float]), (\\\"offset\\\", offset, [int, float])]) if offset\",\n \"--------------------------------------------------------------------------- Drops outliers in the vColumn. Parameters ---------- threshold: float,\",\n \"of {} partitioned by {}.\\\".format( numcol, self.alias ) values =\",\n \"compute other vColumns. Parameters ---------- add_history: bool, optional If set\",\n \": Sum of the vColumn 'of'. q% : q Quantile\",\n \"FROM {}{}GROUP BY {} ORDER BY _verticapy_cnt_ DESC LIMIT {})\",\n \"the vColumn using an input 'quantile'. Parameters ---------- x: float\",\n \"to compute the aggregation. h: int/float/tuple, optional Interval width of\",\n \"expression is in each of the vColumn records. The vColumn\",\n \"vDataFrame input aggregations. \\\"\\\"\\\" check_types( [ (\\\"method\\\", method, [\\\"auto\\\", \\\"numerical\\\",\",\n \"will represent the number of seconds, otherwise it will represent\",\n \"{} DESC LIMIT {}\\\".format( self.parent.__genSQL__(), self.alias, self.alias, n ) title\",\n \"method == \\\"smart\\\" ): n = len(result) trans = \\\"(CASE\",\n \"bool = True): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using an\",\n \"> 1) or (self.category() == \\\"float\\\"): trans = ( \\\"'['\",\n \"number ln : natural logarithm log : logarithm log10 :\",\n \"self.alias, self.alias, self.alias, self.alias, table ) result = executeSQL( query,\",\n \"vColumn using 'unique' (cardinality). Parameters ---------- approx: bool, optional If\",\n \"), \\\"varchar\\\", \\\"text\\\", ) elif self.isnum() and method == \\\"same_freq\\\":\",\n \"drop(self, add_history: bool = True): \\\"\\\"\\\" --------------------------------------------------------------------------- Drops the vColumn\",\n \"variable must be composed of two flower brackets {}. For\",\n \"vColumn category is date. vDataFrame[].isnum : Returns True if the\",\n \"kurtosis : kurtosis jb : Jarque-Bera index mad : median\",\n \"of the vColumn. vDataFrame[].str_replace : Replaces the regular expression matches\",\n \"executeSQL( query, title=\\\"Computing the top{} categories of {}.\\\".format( k if\",\n \"/ uuid / undefined Returns ------- str vColumn category. See\",\n \"the aggregation. h: int/float/tuple, optional Interval width of the vColumns\",\n \"only available for categorical variables.\\\" ) warnings.warn(warning_message, Warning) else: distinct_elements\",\n \"be date like (date, datetime, timestamp...) or numerical. q: tuple,\",\n \"= 0.9) AS 'approx_90%', MAX({3}{4}) AS max FROM vdf_table\\\"\\\"\\\".format( category,\",\n \"See Also -------- vDataFrame[].tail : Returns the a part of\",\n \"len(all_new_features), conj, \\\", \\\".join(all_new_features) ) + \\\".\\\" ) return self.parent\",\n \"Returns a part of the vColumn (delimited by an offset\",\n \"the distinct categories of the vColumn. Returns ------- list Distinct\",\n \"not (isinstance(val, Iterable)): val = [val] val += list(args) check_types([(\\\"val\\\",\",\n \"str = \\\"\\\", prefix_sep: str = \\\"_\\\", drop_first: bool =\",\n \"the vDataFrame Global Outliers. \\\"\\\"\\\" if isinstance(by, str): by =\",\n \"regular expression is in each of the vColumn records. The\",\n \"function's performance can drastically decrease. Returns ------- int vColumn cardinality\",\n \"[ ( \\\"func\\\", func, [ \\\"abs\\\", \\\"acos\\\", \\\"asin\\\", \\\"atan\\\", \\\"cbrt\\\",\",\n \"self.alias, kwargs[\\\"agg\\\"], self.parent.__genSQL__(), self.alias, ) query_result = executeSQL( query=query, title=\\\"Computing\",\n \"bool = False, ): \\\"\\\"\\\" --------------------------------------------------------------------------- Discretizes the vColumn using\",\n \"---------- argv: object Any amount of expressions. The expression generated\",\n \"\\\"-.\\\\ \\\\ # \\\\ \\\\ \\\\'/ \\\\ \\\\ \\\\____ \\\\\",\n \"None: mean_alpha = \\\"NULL\\\" self.apply( func=\\\"(CASE WHEN {} < {}\",\n \"vColumn. Returns ------- list Distinct caterogies of the vColumn. See\",\n \"for column in order_by]) new_column = \\\"COALESCE({}, LAST_VALUE({} IGNORE NULLS)\",\n \"(\\\"RFmodel_params\\\", RFmodel_params, [dict]), (\\\"return_enum_trans\\\", return_enum_trans, [bool]), (\\\"h\\\", h, [int, float]),\",\n \"h, h, floor_end ), \\\"varchar\\\", \\\"text\\\", ) else: trans =\",\n \"the vColumn. Parameters ---------- n: int, optional Offset. Returns -------\",\n \"partitioned by {}.\\\".format( numcol, self.alias ) values = to_tablesample(query, title=title).values\",\n \"DESC LIMIT {1})\\\"\\\"\\\".format( self.alias, max_cardinality ) if distinct_count > max_cardinality:\",\n \"Returns the vColumn database type. \\\"\\\"\\\" return self.transformations[-1][2] # ---#\",\n \"\\\"\\\"\\\" --------------------------------------------------------------------------- Returns the head of the vColumn. Parameters ----------\",\n \"to_tablesample(query, title=title) # ---# def numh(self, method: str = \\\"auto\\\"):\",\n \"\\\"backfill\\\"): assert order_by, ParameterError( \\\"If the method is in ffill|pad|bfill|backfill\",\n \"1\\\".format( new_column.format(self.alias), self.parent.__genSQL__() ), print_time_sql=False, ) except: new_column = \\\"COALESCE({},\",\n \"purpose. Returns ------- vDataFrame self.parent See Also -------- vDataFrame.outliers :\",\n \"{} was discretized.\\\".format(self.alias) ) return self.parent # ---# def distinct(self,\",\n \"length, unit.upper(), start_or_end ) ) # ---# def spider( self,\",\n \"was deleted from the vDataFrame.\\\".format(self.alias) ) return parent # ---#\",\n \"vDataFrame of the search. See Also -------- vDataFrame.isin : Looks\",\n \"_verticapy_cnt_ DESC LIMIT {}) VERTICAPY_SUBTABLE ORDER BY _verticapy_cnt_ ASC LIMIT\",\n \"(PARTITION BY {})\\\".format( self.alias, \\\", \\\".join(by) ), ) else: avg,\",\n \"int = 10): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns the n largest vColumn\",\n \"1993 the 3rd. end_date: str / date, optional Input End\",\n \"def nlargest(self, n: int = 10): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns the\",\n \"topk most frequent categories and merge the other into one\",\n \"best_h = max(math.floor(best_h), 1) return best_h # ---# def nunique(self,\",\n \"return_enum_trans=True, )[0].replace(\\\"{}\\\", self.alias) query = \\\"SELECT {} AS {}, {}\",\n \"func=\\\"REGEXP_COUNT({}, '{}')\\\".format(\\\"{}\\\", pat.replace(\\\"'\\\", \\\"''\\\")) ) # ---# def str_extract(self, pat:\",\n \"Parameters ---------- func: str Function to use to transform the\",\n \"---# def memory_usage(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns the vColumn memory usage.\",\n \"0ifnull : 0 when the vColumn is null, 1 otherwise.\",\n \"= verticapy.options[\\\"temp_schema\\\"] if not (schema): schema = \\\"public\\\" tmp_view_name =\",\n \"each of the vColumn records by an input value. vDataFrame[].str_slice\",\n \"0.75), start_date: Union[str, datetime.datetime, datetime.date] = \\\"\\\", end_date: Union[str, datetime.datetime,\",\n \"in result] ), ) executeSQL( \\\"SELECT {} FROM {} LIMIT\",\n \"verticapy.options[\\\"print_info\\\"]: print(\\\"Nothing was filled.\\\") self.transformations = [elem for elem in\",\n \"{}))\\\".format( \\\"{}\\\", fun, \\\"{}\\\", \\\", \\\".join(by) ) elif method in\",\n \") ax.set_xlabel(self.alias) return ax kernel = kernel.lower() from verticapy.learn.neighbors import\",\n \"if return_trans: return \\\"({} - {}) / {}({} - {})\\\".format(\",\n \": median absolute deviation max : maximum mean : average\",\n \"self.parent.__get_last_order_by__(), limit, offset, ), title=title, ) tail.count = self.parent.shape()[0] tail.offset\",\n \"/ / # \\\\_______/ / / # ______ / /\",\n \"] if mean_alpha == None: mean_alpha = \\\"NULL\\\" if mean_1_alpha\",\n \"\\\"0ifnull\\\": category, ctype = \\\"int\\\", \\\"bool\\\" else: category, ctype =\",\n \"= method.lower() if method == \\\"auto\\\": pre_comp = self.parent.__get_catalog_value__(self.alias, \\\"numh\\\")\",\n \"\\\\__| \\\\ \\\\_____\\\\ \\\\ \\\\_____\\\\ \\\\ \\\\_____\\\\ \\\\ \\\\_____\\\\ \\\\\",\n \"self.catalog[\\\"min\\\"] = 0 self.catalog[\\\"max\\\"] = 1 self.parent.__add_to_history__( \\\"[Normalize]: The vColumn\",\n \"result[idx][0] = ( \\\"NULL\\\" if (elem[0] == None) else \\\"'{}'\\\".format(str(elem[0]).replace(\\\"'\\\",\",\n \"= \\\"COALESCE({}, {}({}) OVER (PARTITION BY {}))\\\".format( \\\"{}\\\", fun, \\\"{}\\\",\",\n \"tablesample(values) # ---# def discretize( self, method: str = \\\"auto\\\",\",\n \"field: str The field to extract. It must be one\",\n \"vColumn using the mean encoding of a response. \\\"\\\"\\\" import\"\n]","isConversational":false}}},{"rowIdx":2498,"cells":{"ngram":{"kind":"list like","value":["from datatables import ColumnDT, DataTables from .. import auth from",": {id}\" @book.route('/post/', methods=['GET', 'POST']) def post_book(): \"\"\" post new","= int(book[-1].id) + 1 print(f\"id is : {id}\") form =","be displayed. from flask import render_template, redirect, request, url_for, flash,jsonify,current_app","from flask import render_template, redirect, request, url_for, flash,jsonify,current_app from flask_login","# GET parameters params = request.args.to_dict() # instantiating a DataTable","col name # :param order: asc or desc # :return:","auth from .. import db from .forms import EditBookForm, HackmdMeta","form.removed.data book.keepsite = form.keepsite.data db.session.add(book) db.session.commit() flash('Your book data has","db from .forms import EditBookForm, HackmdMeta # from booktags.db.basemodels import","%s\\nParameters: %s\\nDuration: %fs\\nContext: %s\\n' % (query.statement, query.parameters, query.duration, query.context)) return","- explicitly cast date to string, so string searching the","import login_user, logout_user, login_required, current_user from . import book from","-*- \"\"\" example.py ~~~~~~~~~ A simple command line application to","# ColumnDT(BookMain.reprint), # ColumnDT(BookMain.removed), # ColumnDT(BookMain.keepsite) ] # defining the","import EditBookForm, HackmdMeta # from booktags.db.basemodels import Book from booktags.flaskapp.model.models","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 = form.title.data book.catalogue = form.catalogue.data book.cutter = form.cutter.data","= book.copy_info form.get_link.data = book.get_link form.note.data = book.note form.reprint.data =","form.title.data = book.title form.catalogue.data = book.catalogue form.cutter.data = book.cutter form.pub_year.data","form.catalogue.data = book.catalogue form.cutter.data = book.cutter form.pub_year.data = book.pub_year form.copy_info.data","%fs\\nContext: %s\\n' % (query.statement, query.parameters, query.duration, query.context)) return response @book.route('/',","data has been updated.', 'success') return redirect(url_for('book.index')) form.id.data = book.id","import auth from .. import db from .forms import EditBookForm,","# \"\"\" # # :param field: col name # :param","response @book.route('/', methods=['GET', 'POST']) def index(): # books=BookMain.get_all_book() query =","in the table columns = [ # ColumnDT(cast(BookMain.id, db.Integer)), ColumnDT(BookMain.id),","# ColumnDT(BookMain.removed), # ColumnDT(BookMain.keepsite) ] # defining the initial query","book.removed = form.removed.data book.keepsite = form.keepsite.data db.session.add(book) db.session.commit() flash('Your book","is a relative path and # the current directory is","db.session.commit() flash('Your book data has been updated.', 'success') return redirect(url_for('book.index'))","book.pub_year form.copy_info.data = book.copy_info form.get_link.data = book.get_link form.note.data = book.note","form.catalogue.data book.cutter = form.cutter.data book.pub_year = form.pub_year.data book.copy_info = form.copy_info.data","form.keepsite.data = book.keepsite return render_template('book/edit_book.html', form=form) @book.route('/del/<int:id>', methods=['GET', 'POST']) def","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),","instantiating a DataTable for the query and table needed rowTable","equal to how it is presented # in the table","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 data :param id: :return: \"\"\" form = EditBookForm() book","\"\"\" from booktags.vendor.hackmd_meta import get_hackmdmeta form = HackmdMeta() if form.validate_on_submit():","% (query.statement, query.parameters, query.duration, query.context)) return response @book.route('/', methods=['GET', 'POST'])",":return: renew query # \"\"\" # books = BookMain.get_all_book() #","= 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","users with DataTables <= 1.10.x.\"\"\" return render_template('book/list_book.html') @book.route('/data', methods=['GET', 'POST'])","return jsonify(rowTable.output_result()) @book.route('/get/<int:id>', methods=['GET', 'POST']) def get_book(): return f\"Hello book","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.pub_year form.copy_info.data = book.copy_info form.get_link.data = book.get_link form.note.data =","query.parameters, query.duration, query.context)) return response @book.route('/', methods=['GET', 'POST']) def index():","%s\\nDuration: %fs\\nContext: %s\\n' % (query.statement, query.parameters, query.duration, query.context)) return response","# 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),","{id}\" @book.route('/hackmdmeta', methods=['GET', 'POST']) def hackmd_meta(): \"\"\" :return: \"\"\" from","= db.session.query().select_from(BookMain) # GET parameters params = request.args.to_dict() # instantiating","-*- coding: utf-8 -*- \"\"\" example.py ~~~~~~~~~ A simple command","params = request.args.to_dict() # instantiating a DataTable for the query","# :param order: asc or desc # :return: renew query","return render_template('book/edit_book.html', form=form) @book.route('/edit/<int:id>', methods=['GET', 'POST']) def edit_book(id): \"\"\" edit","datatables import ColumnDT, DataTables from .. import auth from ..","can't be fixed here: # - synopsis() cannot be prevented","# books=BookMain.get_all_book() query = BookMain.query page = request.args.get('page', 1, type=int)","synopsis() cannot be prevented from clobbering existing # loaded modules.","be fixed here: # - synopsis() cannot be prevented from","field: col name # :param order: asc or desc #","from booktags.db.basemodels import Book from booktags.flaskapp.model.models import BookMain # ---------------------------------------------------------","search a date formatted equal to how it is presented","module is a relative path and # the current directory","f\"Hello book index : {id}\" @book.route('/post/', methods=['GET', 'POST']) def post_book():","defining columns # - explicitly cast date to string, so","# # :param field: col name # :param order: asc","# instantiating a DataTable for the query and table needed",".. import auth from .. import db from .forms import",", put book data :param id: :return: \"\"\" form =",".. import db from .forms import EditBookForm, HackmdMeta # from","book.title = form.title.data book.catalogue = form.catalogue.data book.cutter = form.cutter.data book.pub_year","int(book[-1].id) + 1 print(f\"id is : {id}\") form = EditBookForm()","= book.reprint form.removed.data = book.removed form.keepsite.data = book.keepsite return render_template('book/edit_book.html',","book.reprint form.removed.data = book.removed form.keepsite.data = book.keepsite return render_template('book/edit_book.html', form=form)","form.get_link.data book.note = form.note.data book.reprint = form.reprint.data book.removed = form.removed.data",":return: \"\"\" form = EditBookForm() book = BookMain.query.filter_by(id=id).first_or_404() if form.validate_on_submit():","print(temp) form.body.data = temp # flash('Your book data has been","run flask apps. :copyright: 2019 Miller :license: BSD-3-Clause \"\"\" #",":param id: :return: \"\"\" form = EditBookForm() book = BookMain.query.filter_by(id=id).first_or_404()","your purpose query = db.session.query().select_from(BookMain) # GET parameters params =",": {booksn}\") temp = get_hackmdmeta(booksn) # print(temp) form.body.data = temp","render_template('book/index.html',books=books,pagination=pagination) # @book.route('/list/', methods=['GET', 'POST']) # def list_book(): # \"\"\"","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'])","data(): \"\"\"Return server side data.\"\"\" # defining columns # -","updated.', 'success') return redirect(url_for('book.index')) form.id.data = book.id form.isbn.data = book.isbn","booktags.flaskapp.model.models import BookMain # --------------------------------------------------------- common routines @book.after_app_request def after_request(response):","string searching the date # will search a date formatted","from sqlalchemy.sql.expression import cast from datatables import ColumnDT, DataTables from","'success') # return redirect(url_for('book.hackmd_meta')) return render_template('book/hackmd_meta.html',form=form) if __name__ == '__main__':","desc # :return: renew query # \"\"\" # books =","index(): # books=BookMain.get_all_book() query = BookMain.query page = request.args.get('page', 1,","from flask_login import login_user, logout_user, login_required, current_user from . import","logout_user, login_required, current_user from . import book from flask_sqlalchemy import","print(f\"booksn is : {booksn}\") temp = get_hackmdmeta(booksn) # print(temp) form.body.data","get_debug_queries from sqlalchemy.sql.expression import cast from datatables import ColumnDT, DataTables","edit_book(id): \"\"\" edit , put book data :param id: :return:","\"\"\" form = EditBookForm() book = BookMain.query.filter_by(id=id).first_or_404() if form.validate_on_submit(): #","methods=['GET', 'POST']) def post_book(): \"\"\" post new book entry :return:","form.title.data book.catalogue = form.catalogue.data book.cutter = form.cutter.data book.pub_year = form.pub_year.data","= form.title.data book.catalogue = form.catalogue.data book.cutter = form.cutter.data book.pub_year =",": {id}\") form = EditBookForm() if form.validate_on_submit(): book.id = form.id.data","request, url_for, flash,jsonify,current_app from flask_login import login_user, logout_user, login_required, current_user","from .forms import EditBookForm, HackmdMeta # from booktags.db.basemodels import Book","BookMain # --------------------------------------------------------- common routines @book.after_app_request def after_request(response): for query","index : {id}\" @book.route('/post/', methods=['GET', 'POST']) def post_book(): \"\"\" post","def list_book(): # \"\"\" # # :param field: col name","= HackmdMeta() if form.validate_on_submit(): booksn = str(form.booksn.data) # print(f\"booksn is","ColumnDT(BookMain.get_link), # ColumnDT(BookMain.note), # ColumnDT(BookMain.reprint), # ColumnDT(BookMain.removed), # ColumnDT(BookMain.keepsite) ]","book data has been updated.', 'success') return redirect(url_for('book.index')) form.id.data =","(query.statement, query.parameters, query.duration, query.context)) return response @book.route('/', methods=['GET', 'POST']) def","the table columns = [ # ColumnDT(cast(BookMain.id, db.Integer)), ColumnDT(BookMain.id), ColumnDT(BookMain.isbn),","index: del {id}\" @book.route('/hackmdmeta', methods=['GET', 'POST']) def hackmd_meta(): \"\"\" :return:","side data.\"\"\" # defining columns # - explicitly cast date","be prevented from clobbering existing # loaded modules. # -","- synopsis() cannot be prevented from clobbering existing # loaded","on a module is a relative path and # the","string, so string searching the date # will search a","form.id.data book.isbn = form.isbn.data book.title_short = form.title_short.data book.title = form.title.data","os.chdir(), an incorrect # path will be displayed. from flask","query, columns) # returns what is needed by DataTable return","the __file__ attribute on a module is a relative path","= form.id.data book.isbn = form.isbn.data book.title_short = form.title_short.data book.title =","'POST']) def data(): \"\"\"Return server side data.\"\"\" # defining columns","form.body.data = temp # flash('Your book data has been updated.',","flash,jsonify,current_app from flask_login import login_user, logout_user, login_required, current_user from .","# ColumnDT(BookMain.get_link), # ColumnDT(BookMain.note), # ColumnDT(BookMain.reprint), # ColumnDT(BookMain.removed), # ColumnDT(BookMain.keepsite)","BookMain.get_all_book() # return render_template('book/list_book.html',books=books) @book.route(\"/list\") def list_book(): \"\"\"List users with","def hackmd_meta(): \"\"\" :return: \"\"\" from booktags.vendor.hackmd_meta import get_hackmdmeta form","book.isbn = form.isbn.data book.title_short = form.title_short.data book.title = form.title.data book.catalogue","form = EditBookForm() if form.validate_on_submit(): book.id = form.id.data book.isbn =","the current directory is changed with os.chdir(), an incorrect #","application to run flask apps. :copyright: 2019 Miller :license: BSD-3-Clause","form.copy_info.data book.get_link = form.get_link.data book.note = form.note.data book.reprint = form.reprint.data","book.isbn form.title_short.data = book.title_short form.title.data = book.title form.catalogue.data = book.catalogue","with os.chdir(), an incorrect # path will be displayed. from","date formatted equal to how it is presented # in","ColumnDT(BookMain.note), # ColumnDT(BookMain.reprint), # ColumnDT(BookMain.removed), # ColumnDT(BookMain.keepsite) ] # defining","del_book(id): return f\"Hello book index: del {id}\" @book.route('/hackmdmeta', methods=['GET', 'POST'])","'POST']) def hackmd_meta(): \"\"\" :return: \"\"\" from booktags.vendor.hackmd_meta import get_hackmdmeta","to how it is presented # in the table columns","1.10.x.\"\"\" return render_template('book/list_book.html') @book.route('/data', methods=['GET', 'POST']) def data(): \"\"\"Return server","form=form) @book.route('/edit/<int:id>', methods=['GET', 'POST']) def edit_book(id): \"\"\" edit , put","~~~~~~~~~ A simple command line application to run flask apps.","form.validate_on_submit(): booksn = str(form.booksn.data) # print(f\"booksn is : {booksn}\") temp","from booktags.vendor.hackmd_meta import get_hackmdmeta form = HackmdMeta() if form.validate_on_submit(): booksn","def index(): # books=BookMain.get_all_book() query = BookMain.query page = request.args.get('page',","been updated.', 'success') # return redirect(url_for('book.hackmd_meta')) return render_template('book/hackmd_meta.html',form=form) if __name__",". import book from flask_sqlalchemy import get_debug_queries from sqlalchemy.sql.expression import","ColumnDT(BookMain.removed), # ColumnDT(BookMain.keepsite) ] # defining the initial query depending","= book.id form.isbn.data = book.isbn form.title_short.data = book.title_short form.title.data =","= temp # flash('Your book data has been updated.', 'success')","'POST']) def del_book(id): return f\"Hello book index: del {id}\" @book.route('/hackmdmeta',","form.copy_info.data = book.copy_info form.get_link.data = book.get_link form.note.data = book.note form.reprint.data","return render_template('book/list_book.html',books=books) @book.route(\"/list\") def list_book(): \"\"\"List users with DataTables <=","def data(): \"\"\"Return server side data.\"\"\" # defining columns #","= form.note.data book.reprint = form.reprint.data book.removed = form.removed.data book.keepsite =","= 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'],","after_request(response): for query in get_debug_queries(): if query.duration >= current_app.config['PROJECT_SLOW_DB_QUERY_TIME']: current_app.logger.warning(","= form.pub_year.data book.copy_info = form.copy_info.data book.get_link = form.get_link.data book.note =","return render_template('book/index.html',books=books,pagination=pagination) # @book.route('/list/', methods=['GET', 'POST']) # def list_book(): #","utf-8 -*- \"\"\" example.py ~~~~~~~~~ A simple command line application","a relative path and # the current directory is changed","cast from datatables import ColumnDT, DataTables from .. import auth","book data has been added.', 'success') return redirect(url_for('book.index')) form.id.data =","put book data :param id: :return: \"\"\" form = EditBookForm()","# in the table columns = [ # ColumnDT(cast(BookMain.id, db.Integer)),","if form.validate_on_submit(): # book.id = form.id.data book.isbn = form.isbn.data book.title_short","book.note = form.note.data book.reprint = form.reprint.data book.removed = form.removed.data book.keepsite","attribute on a module is a relative path and #","# defining the initial query depending on your purpose query","= book.removed form.keepsite.data = book.keepsite return render_template('book/edit_book.html', form=form) @book.route('/del/<int:id>', methods=['GET',","temp # flash('Your book data has been updated.', 'success') #","has been added.', 'success') return redirect(url_for('book.index')) form.id.data = id return","--------------------------------------------------------- common routines @book.after_app_request def after_request(response): for query in get_debug_queries():","If the __file__ attribute on a module is a relative","1 print(f\"id is : {id}\") form = EditBookForm() if form.validate_on_submit():","page = request.args.get('page', 1, type=int) pagination = query.order_by(cast(BookMain.id, db.Integer)).paginate( page,","= form.title_short.data book.title = form.title.data book.catalogue = form.catalogue.data book.cutter =","ColumnDT(BookMain.catalogue), ColumnDT(BookMain.cutter), ColumnDT(BookMain.pub_year), ColumnDT(BookMain.copy_info) # ColumnDT(BookMain.get_link), # ColumnDT(BookMain.note), # ColumnDT(BookMain.reprint),","@book.route('/list/', methods=['GET', 'POST']) # def list_book(): # \"\"\" # #","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)","form = HackmdMeta() if form.validate_on_submit(): booksn = str(form.booksn.data) # print(f\"booksn","= form.keepsite.data db.session.add(book) db.session.commit() flash('Your book data has been added.',","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 = BookMain.query.all() id = int(book[-1].id) + 1 print(f\"id is","'POST']) def edit_book(id): \"\"\" edit , put book data :param","form.note.data book.reprint = form.reprint.data book.removed = form.removed.data book.keepsite = form.keepsite.data","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',","'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>',","query in get_debug_queries(): if query.duration >= current_app.config['PROJECT_SLOW_DB_QUERY_TIME']: current_app.logger.warning( 'Slow query:","error_out=False) books = pagination.items return render_template('book/index.html',books=books,pagination=pagination) # @book.route('/list/', methods=['GET', 'POST'])","= id return render_template('book/edit_book.html', form=form) @book.route('/edit/<int:id>', methods=['GET', 'POST']) def edit_book(id):","apps. :copyright: 2019 Miller :license: BSD-3-Clause \"\"\" # Known bugs","flask_sqlalchemy import get_debug_queries from sqlalchemy.sql.expression import cast from datatables import","book entry :return: \"\"\" book = BookMain.query.all() id = int(book[-1].id)","has been updated.', 'success') return redirect(url_for('book.index')) form.id.data = book.id form.isbn.data","Known bugs that can't be fixed here: # - synopsis()","current directory is changed with os.chdir(), an incorrect # path","table needed rowTable = DataTables(params, query, columns) # returns what","GET parameters params = request.args.to_dict() # instantiating a DataTable for","'success') return redirect(url_for('book.index')) form.id.data = book.id form.isbn.data = book.isbn form.title_short.data","= BookMain.query page = request.args.get('page', 1, type=int) pagination = query.order_by(cast(BookMain.id,","current_app.logger.warning( 'Slow query: %s\\nParameters: %s\\nDuration: %fs\\nContext: %s\\n' % (query.statement, query.parameters,","\"\"\" # books = BookMain.get_all_book() # return render_template('book/list_book.html',books=books) @book.route(\"/list\") def","# - synopsis() cannot be prevented from clobbering existing #","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.context)) return response @book.route('/', methods=['GET', 'POST']) def index(): # books=BookMain.get_all_book()","form.isbn.data = book.isbn form.title_short.data = book.title_short form.title.data = book.title form.catalogue.data","explicitly cast date to string, so string searching the date","query depending on your purpose query = db.session.query().select_from(BookMain) # GET","+ 1 print(f\"id is : {id}\") form = EditBookForm() if","= EditBookForm() if form.validate_on_submit(): book.id = form.id.data book.isbn = form.isbn.data","modules. # - If the __file__ attribute on a module","book.title_short = form.title_short.data book.title = form.title.data book.catalogue = form.catalogue.data book.cutter","'POST']) def post_book(): \"\"\" post new book entry :return: \"\"\"","book index : {id}\" @book.route('/post/', methods=['GET', 'POST']) def post_book(): \"\"\"","book.cutter = form.cutter.data book.pub_year = form.pub_year.data book.copy_info = form.copy_info.data book.get_link",":copyright: 2019 Miller :license: BSD-3-Clause \"\"\" # Known bugs that","{booksn}\") temp = get_hackmdmeta(booksn) # print(temp) form.body.data = temp #","<reponame>MagicSword/Booktags #!/usr/bin/env python3 # -*- coding: utf-8 -*- \"\"\" example.py","form.isbn.data book.title_short = form.title_short.data book.title = form.title.data book.catalogue = form.catalogue.data","f\"Hello book index: del {id}\" @book.route('/hackmdmeta', methods=['GET', 'POST']) def hackmd_meta():","# ColumnDT(BookMain.note), # ColumnDT(BookMain.reprint), # ColumnDT(BookMain.removed), # ColumnDT(BookMain.keepsite) ] #","#!/usr/bin/env python3 # -*- coding: utf-8 -*- \"\"\" example.py ~~~~~~~~~","BSD-3-Clause \"\"\" # Known bugs that can't be fixed here:","= BookMain.query.filter_by(id=id).first_or_404() if form.validate_on_submit(): # book.id = form.id.data book.isbn =","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.cutter.data book.pub_year = form.pub_year.data book.copy_info = form.copy_info.data book.get_link =","A simple command line application to run flask apps. :copyright:","data :param id: :return: \"\"\" form = EditBookForm() book =","form.keepsite.data db.session.add(book) db.session.commit() flash('Your book data has been added.', 'success')","order: asc or desc # :return: renew query # \"\"\"","import render_template, redirect, request, url_for, flash,jsonify,current_app from flask_login import login_user,","render_template('book/list_book.html',books=books) @book.route(\"/list\") def list_book(): \"\"\"List users with DataTables <= 1.10.x.\"\"\"","post new book entry :return: \"\"\" book = BookMain.query.all() id","book data has been updated.', 'success') # return redirect(url_for('book.hackmd_meta')) return","flash('Your book data has been added.', 'success') return redirect(url_for('book.index')) form.id.data","= book.cutter form.pub_year.data = book.pub_year form.copy_info.data = book.copy_info form.get_link.data =","relative path and # the current directory is changed with","query.duration >= current_app.config['PROJECT_SLOW_DB_QUERY_TIME']: current_app.logger.warning( 'Slow query: %s\\nParameters: %s\\nDuration: %fs\\nContext: %s\\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.id = form.id.data book.isbn = form.isbn.data book.title_short = form.title_short.data book.title","= EditBookForm() book = BookMain.query.filter_by(id=id).first_or_404() if form.validate_on_submit(): # book.id =","db.session.add(book) db.session.commit() flash('Your book data has been updated.', 'success') return",">= current_app.config['PROJECT_SLOW_DB_QUERY_TIME']: current_app.logger.warning( 'Slow query: %s\\nParameters: %s\\nDuration: %fs\\nContext: %s\\n' %","jsonify(rowTable.output_result()) @book.route('/get/<int:id>', methods=['GET', 'POST']) def get_book(): return f\"Hello book index","from .. import auth from .. import db from .forms","data has been added.', 'success') return redirect(url_for('book.index')) form.id.data = id","query = BookMain.query page = request.args.get('page', 1, type=int) pagination =","prevented from clobbering existing # loaded modules. # - If","# def list_book(): # \"\"\" # # :param field: col","# print(temp) form.body.data = temp # flash('Your book data has","\"\"\" :return: \"\"\" from booktags.vendor.hackmd_meta import get_hackmdmeta form = HackmdMeta()","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 =","@book.route('/data', methods=['GET', 'POST']) def data(): \"\"\"Return server side data.\"\"\" #","query and table needed rowTable = DataTables(params, query, columns) #","= form.copy_info.data book.get_link = form.get_link.data book.note = form.note.data book.reprint =","] # defining the initial query depending on your purpose","id = int(book[-1].id) + 1 print(f\"id is : {id}\") form","been updated.', 'success') return redirect(url_for('book.index')) form.id.data = book.id form.isbn.data =","that can't be fixed here: # - synopsis() cannot be","sqlalchemy.sql.expression import cast from datatables import ColumnDT, DataTables from ..","query: %s\\nParameters: %s\\nDuration: %fs\\nContext: %s\\n' % (query.statement, query.parameters, query.duration, query.context))","ColumnDT(BookMain.title), ColumnDT(BookMain.catalogue), ColumnDT(BookMain.cutter), ColumnDT(BookMain.pub_year), ColumnDT(BookMain.copy_info) # ColumnDT(BookMain.get_link), # ColumnDT(BookMain.note), #","directory is changed with os.chdir(), an incorrect # path will","get_hackmdmeta(booksn) # print(temp) form.body.data = temp # flash('Your book data","return render_template('book/edit_book.html', form=form) @book.route('/del/<int:id>', methods=['GET', 'POST']) def del_book(id): return f\"Hello","= DataTables(params, query, columns) # returns what is needed by","with DataTables <= 1.10.x.\"\"\" return render_template('book/list_book.html') @book.route('/data', methods=['GET', 'POST']) def","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.note form.reprint.data = book.reprint form.removed.data = book.removed form.keepsite.data =","# books = BookMain.get_all_book() # return render_template('book/list_book.html',books=books) @book.route(\"/list\") def list_book():","= book.get_link form.note.data = book.note form.reprint.data = book.reprint form.removed.data =","str(form.booksn.data) # print(f\"booksn is : {booksn}\") temp = get_hackmdmeta(booksn) #","book index: del {id}\" @book.route('/hackmdmeta', methods=['GET', 'POST']) def hackmd_meta(): \"\"\"","# return render_template('book/list_book.html',books=books) @book.route(\"/list\") def list_book(): \"\"\"List users with DataTables","been added.', 'success') return redirect(url_for('book.index')) form.id.data = id return render_template('book/edit_book.html',","needed by DataTable return jsonify(rowTable.output_result()) @book.route('/get/<int:id>', methods=['GET', 'POST']) def get_book():","booksn = str(form.booksn.data) # print(f\"booksn is : {booksn}\") temp =","= pagination.items return render_template('book/index.html',books=books,pagination=pagination) # @book.route('/list/', methods=['GET', 'POST']) # def","form.validate_on_submit(): # book.id = form.id.data book.isbn = form.isbn.data book.title_short =","an incorrect # path will be displayed. from flask import","cast date to string, so string searching the date #","columns = [ # ColumnDT(cast(BookMain.id, db.Integer)), ColumnDT(BookMain.id), ColumnDT(BookMain.isbn), ColumnDT(BookMain.title_short), ColumnDT(BookMain.title),","temp = get_hackmdmeta(booksn) # print(temp) form.body.data = temp # flash('Your","formatted equal to how it is presented # in the","from . import book from flask_sqlalchemy import get_debug_queries from sqlalchemy.sql.expression","ColumnDT(BookMain.reprint), # ColumnDT(BookMain.removed), # ColumnDT(BookMain.keepsite) ] # defining the initial","# Known bugs that can't be fixed here: # -","login_required, current_user from . import book from flask_sqlalchemy import get_debug_queries","book.keepsite return render_template('book/edit_book.html', form=form) @book.route('/del/<int:id>', methods=['GET', 'POST']) def del_book(id): return","methods=['GET', 'POST']) def del_book(id): return f\"Hello book index: del {id}\"","def edit_book(id): \"\"\" edit , put book data :param id:","= BookMain.get_all_book() # return render_template('book/list_book.html',books=books) @book.route(\"/list\") def list_book(): \"\"\"List users","request.args.to_dict() # instantiating a DataTable for the query and table","# print(f\"booksn is : {booksn}\") temp = get_hackmdmeta(booksn) # print(temp)","form.removed.data = book.removed form.keepsite.data = book.keepsite return render_template('book/edit_book.html', form=form) @book.route('/del/<int:id>',","\"\"\" edit , put book data :param id: :return: \"\"\"","date # will search a date formatted equal to how","# :param field: col name # :param order: asc or","- If the __file__ attribute on a module is a","form.reprint.data book.removed = form.removed.data book.keepsite = form.keepsite.data db.session.add(book) db.session.commit() flash('Your","# will search a date formatted equal to how it","asc or desc # :return: renew query # \"\"\" #","redirect(url_for('book.index')) form.id.data = book.id form.isbn.data = book.isbn form.title_short.data = book.title_short","DataTables from .. import auth from .. import db from","changed with os.chdir(), an incorrect # path will be displayed.","methods=['GET', 'POST']) def get_book(): return f\"Hello book index : {id}\"","# flash('Your book data has been updated.', 'success') # return","methods=['GET', 'POST']) # def list_book(): # \"\"\" # # :param","# path will be displayed. from flask import render_template, redirect,","will search a date formatted equal to how it is","in get_debug_queries(): if query.duration >= current_app.config['PROJECT_SLOW_DB_QUERY_TIME']: current_app.logger.warning( 'Slow query: %s\\nParameters:","form=form) @book.route('/del/<int:id>', methods=['GET', 'POST']) def del_book(id): return f\"Hello book index:","{id}\") form = EditBookForm() if form.validate_on_submit(): book.id = form.id.data book.isbn","defining the initial query depending on your purpose query =","= book.title form.catalogue.data = book.catalogue form.cutter.data = book.cutter form.pub_year.data =","form.id.data = id return render_template('book/edit_book.html', form=form) @book.route('/edit/<int:id>', methods=['GET', 'POST']) def","has been updated.', 'success') # return redirect(url_for('book.hackmd_meta')) return render_template('book/hackmd_meta.html',form=form) if","displayed. from flask import render_template, redirect, request, url_for, flash,jsonify,current_app from","depending on your purpose query = db.session.query().select_from(BookMain) # GET parameters","initial query depending on your purpose query = db.session.query().select_from(BookMain) #","a date formatted equal to how it is presented #","= book.keepsite return render_template('book/edit_book.html', form=form) @book.route('/del/<int:id>', methods=['GET', 'POST']) def del_book(id):","get_hackmdmeta form = HackmdMeta() if form.validate_on_submit(): booksn = str(form.booksn.data) #","print(f\"id is : {id}\") form = EditBookForm() if form.validate_on_submit(): book.id","@book.route('/edit/<int:id>', methods=['GET', 'POST']) def edit_book(id): \"\"\" edit , put book","id: :return: \"\"\" form = EditBookForm() book = BookMain.query.filter_by(id=id).first_or_404() if","pagination.items return render_template('book/index.html',books=books,pagination=pagination) # @book.route('/list/', methods=['GET', 'POST']) # def list_book():","incorrect # path will be displayed. from flask import render_template,","book from flask_sqlalchemy import get_debug_queries from sqlalchemy.sql.expression import cast from","db.session.add(book) db.session.commit() flash('Your book data has been added.', 'success') return","book.get_link = form.get_link.data book.note = form.note.data book.reprint = form.reprint.data book.removed","\"\"\" # # :param field: col name # :param order:","what is needed by DataTable return jsonify(rowTable.output_result()) @book.route('/get/<int:id>', methods=['GET', 'POST'])","example.py ~~~~~~~~~ A simple command line application to run flask","post_book(): \"\"\" post new book entry :return: \"\"\" book =","# defining columns # - explicitly cast date to string,","list_book(): # \"\"\" # # :param field: col name #","date to string, so string searching the date # will","@book.route('/del/<int:id>', methods=['GET', 'POST']) def del_book(id): return f\"Hello book index: del","'POST']) def get_book(): return f\"Hello book index : {id}\" @book.route('/post/',","import get_hackmdmeta form = HackmdMeta() if form.validate_on_submit(): booksn = str(form.booksn.data)","= form.reprint.data book.removed = form.removed.data book.keepsite = form.keepsite.data db.session.add(book) db.session.commit()","routines @book.after_app_request def after_request(response): for query in get_debug_queries(): if query.duration","get_book(): return f\"Hello book index : {id}\" @book.route('/post/', methods=['GET', 'POST'])","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',","data.\"\"\" # defining columns # - explicitly cast date to","from .. import db from .forms import EditBookForm, HackmdMeta #","existing # loaded modules. # - If the __file__ attribute","form.pub_year.data book.copy_info = form.copy_info.data book.get_link = form.get_link.data book.note = form.note.data","book.catalogue = form.catalogue.data book.cutter = form.cutter.data book.pub_year = form.pub_year.data book.copy_info","render_template('book/list_book.html') @book.route('/data', methods=['GET', 'POST']) def data(): \"\"\"Return server side data.\"\"\"","DataTables <= 1.10.x.\"\"\" return render_template('book/list_book.html') @book.route('/data', methods=['GET', 'POST']) def data():","EditBookForm, HackmdMeta # from booktags.db.basemodels import Book from booktags.flaskapp.model.models import","book.title_short form.title.data = book.title form.catalogue.data = book.catalogue form.cutter.data = book.cutter","__file__ attribute on a module is a relative path and","import BookMain # --------------------------------------------------------- common routines @book.after_app_request def after_request(response): for","= str(form.booksn.data) # print(f\"booksn is : {booksn}\") temp = get_hackmdmeta(booksn)","on your purpose query = db.session.query().select_from(BookMain) # GET parameters params","\"\"\" post new book entry :return: \"\"\" book = BookMain.query.all()","flask apps. :copyright: 2019 Miller :license: BSD-3-Clause \"\"\" # Known","= get_hackmdmeta(booksn) # print(temp) form.body.data = temp # flash('Your book","def del_book(id): return f\"Hello book index: del {id}\" @book.route('/hackmdmeta', methods=['GET',","= form.catalogue.data book.cutter = form.cutter.data book.pub_year = form.pub_year.data book.copy_info =","coding: utf-8 -*- \"\"\" example.py ~~~~~~~~~ A simple command line","simple command line application to run flask apps. :copyright: 2019","so string searching the date # will search a date","def post_book(): \"\"\" post new book entry :return: \"\"\" book","db.session.commit() flash('Your book data has been added.', 'success') return redirect(url_for('book.index'))","the query and table needed rowTable = DataTables(params, query, columns)","clobbering existing # loaded modules. # - If the __file__","= book.title_short form.title.data = book.title form.catalogue.data = book.catalogue form.cutter.data =",":license: BSD-3-Clause \"\"\" # Known bugs that can't be fixed","HackmdMeta # from booktags.db.basemodels import Book from booktags.flaskapp.model.models import BookMain","import cast from datatables import ColumnDT, DataTables from .. import","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","# returns what is needed by DataTable return jsonify(rowTable.output_result()) @book.route('/get/<int:id>',","= form.isbn.data book.title_short = form.title_short.data book.title = form.title.data book.catalogue =","@book.route('/post/', methods=['GET', 'POST']) def post_book(): \"\"\" post new book entry","command line application to run flask apps. :copyright: 2019 Miller","return f\"Hello book index: del {id}\" @book.route('/hackmdmeta', methods=['GET', 'POST']) def","url_for, flash,jsonify,current_app from flask_login import login_user, logout_user, login_required, current_user from","# ColumnDT(BookMain.keepsite) ] # defining the initial query depending on","for query in get_debug_queries(): if query.duration >= current_app.config['PROJECT_SLOW_DB_QUERY_TIME']: current_app.logger.warning( 'Slow","return render_template('book/list_book.html') @book.route('/data', methods=['GET', 'POST']) def data(): \"\"\"Return server side","import Book from booktags.flaskapp.model.models import BookMain # --------------------------------------------------------- common routines","= form.removed.data book.keepsite = form.keepsite.data db.session.add(book) db.session.commit() flash('Your book data","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/',","%s\\n' % (query.statement, query.parameters, query.duration, query.context)) return response @book.route('/', methods=['GET',","server side data.\"\"\" # defining columns # - explicitly cast","the initial query depending on your purpose query = db.session.query().select_from(BookMain)","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) #","book.get_link form.note.data = book.note form.reprint.data = book.reprint form.removed.data = book.removed","book.id form.isbn.data = book.isbn form.title_short.data = book.title_short form.title.data = book.title","entry :return: \"\"\" book = BookMain.query.all() id = int(book[-1].id) +","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)","path and # the current directory is changed with os.chdir(),","form.cutter.data book.pub_year = form.pub_year.data book.copy_info = form.copy_info.data book.get_link = form.get_link.data","common routines @book.after_app_request def after_request(response): for query in get_debug_queries(): if","the date # will search a date formatted equal to","# \"\"\" # books = BookMain.get_all_book() # return render_template('book/list_book.html',books=books) @book.route(\"/list\")","updated.', 'success') # return redirect(url_for('book.hackmd_meta')) return render_template('book/hackmd_meta.html',form=form) if __name__ ==","import get_debug_queries from sqlalchemy.sql.expression import cast from datatables import ColumnDT,","data has been updated.', 'success') # return redirect(url_for('book.hackmd_meta')) return render_template('book/hackmd_meta.html',form=form)",".forms import EditBookForm, HackmdMeta # from booktags.db.basemodels import Book from","python3 # -*- coding: utf-8 -*- \"\"\" example.py ~~~~~~~~~ A","form.title_short.data = book.title_short form.title.data = book.title form.catalogue.data = book.catalogue form.cutter.data","# --------------------------------------------------------- common routines @book.after_app_request def after_request(response): for query in","HackmdMeta() if form.validate_on_submit(): booksn = str(form.booksn.data) # print(f\"booksn is :","it is presented # in the table columns = [","del {id}\" @book.route('/hackmdmeta', methods=['GET', 'POST']) def hackmd_meta(): \"\"\" :return: \"\"\"",":param order: asc or desc # :return: renew query #","login_user, logout_user, login_required, current_user from . import book from flask_sqlalchemy","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)","for the query and table needed rowTable = DataTables(params, query,","query # \"\"\" # books = BookMain.get_all_book() # return render_template('book/list_book.html',books=books)","books = pagination.items return render_template('book/index.html',books=books,pagination=pagination) # @book.route('/list/', methods=['GET', 'POST']) #","form.note.data = book.note form.reprint.data = book.reprint form.removed.data = book.removed form.keepsite.data","form.get_link.data = book.get_link form.note.data = book.note form.reprint.data = book.reprint form.removed.data","will be displayed. from flask import render_template, redirect, request, url_for,","path will be displayed. from flask import render_template, redirect, request,","book = BookMain.query.filter_by(id=id).first_or_404() if form.validate_on_submit(): # book.id = form.id.data book.isbn","ColumnDT(BookMain.keepsite) ] # defining the initial query depending on your","BookMain.query.all() id = int(book[-1].id) + 1 print(f\"id is : {id}\")","list_book(): \"\"\"List users with DataTables <= 1.10.x.\"\"\" return render_template('book/list_book.html') @book.route('/data',",":param field: col name # :param order: asc or desc","presented # in the table columns = [ # ColumnDT(cast(BookMain.id,","book.pub_year = form.pub_year.data book.copy_info = form.copy_info.data book.get_link = form.get_link.data book.note","query = db.session.query().select_from(BookMain) # GET parameters params = request.args.to_dict() #","redirect, request, url_for, flash,jsonify,current_app from flask_login import login_user, logout_user, login_required,","book.copy_info form.get_link.data = book.get_link form.note.data = book.note form.reprint.data = book.reprint","a DataTable for the query and table needed rowTable =","import ColumnDT, DataTables from .. import auth from .. import","to string, so string searching the date # will search","current_user from . import book from flask_sqlalchemy import get_debug_queries from","# from booktags.db.basemodels import Book from booktags.flaskapp.model.models import BookMain #","ColumnDT(BookMain.copy_info) # ColumnDT(BookMain.get_link), # ColumnDT(BookMain.note), # ColumnDT(BookMain.reprint), # ColumnDT(BookMain.removed), #","added.', 'success') return redirect(url_for('book.index')) form.id.data = id return render_template('book/edit_book.html', form=form)","# - If the __file__ attribute on a module is","# -*- coding: utf-8 -*- \"\"\" example.py ~~~~~~~~~ A simple",":return: \"\"\" from booktags.vendor.hackmd_meta import get_hackmdmeta form = HackmdMeta() if","methods=['GET', 'POST']) def hackmd_meta(): \"\"\" :return: \"\"\" from booktags.vendor.hackmd_meta import","import book from flask_sqlalchemy import get_debug_queries from sqlalchemy.sql.expression import cast","form.keepsite.data db.session.add(book) db.session.commit() flash('Your book data has been updated.', 'success')","columns # - explicitly cast date to string, so string","a module is a relative path and # the current","return response @book.route('/', methods=['GET', 'POST']) def index(): # books=BookMain.get_all_book() query","# :return: renew query # \"\"\" # books = BookMain.get_all_book()","# - explicitly cast date to string, so string searching","{id}\" @book.route('/post/', methods=['GET', 'POST']) def post_book(): \"\"\" post new book","# @book.route('/list/', methods=['GET', 'POST']) # def list_book(): # \"\"\" #","\"\"\"Return server side data.\"\"\" # defining columns # - explicitly","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.copy_info = form.copy_info.data book.get_link = form.get_link.data book.note = form.note.data book.reprint","EditBookForm() if form.validate_on_submit(): book.id = form.id.data book.isbn = form.isbn.data book.title_short","book.reprint = form.reprint.data book.removed = form.removed.data book.keepsite = form.keepsite.data db.session.add(book)","booktags.vendor.hackmd_meta import get_hackmdmeta form = HackmdMeta() if form.validate_on_submit(): booksn =","\"\"\" book = BookMain.query.all() id = int(book[-1].id) + 1 print(f\"id","from clobbering existing # loaded modules. # - If the","= form.keepsite.data db.session.add(book) db.session.commit() flash('Your book data has been updated.',","is needed by DataTable return jsonify(rowTable.output_result()) @book.route('/get/<int:id>', methods=['GET', 'POST']) def","@book.after_app_request def after_request(response): for query in get_debug_queries(): if query.duration >=","<= 1.10.x.\"\"\" return render_template('book/list_book.html') @book.route('/data', methods=['GET', 'POST']) def data(): \"\"\"Return","flask import render_template, redirect, request, url_for, flash,jsonify,current_app from flask_login import","db.session.query().select_from(BookMain) # GET parameters params = request.args.to_dict() # instantiating a","new book entry :return: \"\"\" book = BookMain.query.all() id =","book.title form.catalogue.data = book.catalogue form.cutter.data = book.cutter form.pub_year.data = book.pub_year","methods=['GET', 'POST']) def index(): # books=BookMain.get_all_book() query = BookMain.query page","or desc # :return: renew query # \"\"\" # books","\"\"\" # Known bugs that can't be fixed here: #","fixed here: # - synopsis() cannot be prevented from clobbering","to run flask apps. :copyright: 2019 Miller :license: BSD-3-Clause \"\"\"","DataTable return jsonify(rowTable.output_result()) @book.route('/get/<int:id>', methods=['GET', 'POST']) def get_book(): return f\"Hello","import db from .forms import EditBookForm, HackmdMeta # from booktags.db.basemodels","= book.isbn form.title_short.data = book.title_short form.title.data = book.title form.catalogue.data =","def after_request(response): for query in get_debug_queries(): if query.duration >= current_app.config['PROJECT_SLOW_DB_QUERY_TIME']:","books=BookMain.get_all_book() query = BookMain.query page = request.args.get('page', 1, type=int) pagination","name # :param order: asc or desc # :return: renew","rowTable = DataTables(params, query, columns) # returns what is needed","'POST']) def index(): # books=BookMain.get_all_book() query = BookMain.query page =","return redirect(url_for('book.index')) form.id.data = book.id form.isbn.data = book.isbn form.title_short.data =","methods=['GET', 'POST']) def edit_book(id): \"\"\" edit , put book data","by DataTable return jsonify(rowTable.output_result()) @book.route('/get/<int:id>', methods=['GET', 'POST']) def get_book(): return","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","and # the current directory is changed with os.chdir(), an","2019 Miller :license: BSD-3-Clause \"\"\" # Known bugs that can't","if form.validate_on_submit(): book.id = form.id.data book.isbn = form.isbn.data book.title_short =","flask_login import login_user, logout_user, login_required, current_user from . import book","from booktags.flaskapp.model.models import BookMain # --------------------------------------------------------- common routines @book.after_app_request def","'Slow query: %s\\nParameters: %s\\nDuration: %fs\\nContext: %s\\n' % (query.statement, query.parameters, query.duration,","ColumnDT(BookMain.cutter), ColumnDT(BookMain.pub_year), ColumnDT(BookMain.copy_info) # ColumnDT(BookMain.get_link), # ColumnDT(BookMain.note), # ColumnDT(BookMain.reprint), #","parameters params = request.args.to_dict() # instantiating a DataTable for the","render_template('book/edit_book.html', form=form) @book.route('/del/<int:id>', methods=['GET', 'POST']) def del_book(id): return f\"Hello book","hackmd_meta(): \"\"\" :return: \"\"\" from booktags.vendor.hackmd_meta import get_hackmdmeta form =","booktags.db.basemodels import Book from booktags.flaskapp.model.models import BookMain # --------------------------------------------------------- common","# the current directory is changed with os.chdir(), an incorrect","render_template('book/edit_book.html', form=form) @book.route('/edit/<int:id>', methods=['GET', 'POST']) def edit_book(id): \"\"\" edit ,","@book.route('/hackmdmeta', methods=['GET', 'POST']) def hackmd_meta(): \"\"\" :return: \"\"\" from booktags.vendor.hackmd_meta","= BookMain.query.all() id = int(book[-1].id) + 1 print(f\"id is :","return f\"Hello book index : {id}\" @book.route('/post/', methods=['GET', 'POST']) def","@book.route(\"/list\") def list_book(): \"\"\"List users with DataTables <= 1.10.x.\"\"\" return","how it is presented # in the table columns =","is changed with os.chdir(), an incorrect # path will be","if query.duration >= current_app.config['PROJECT_SLOW_DB_QUERY_TIME']: current_app.logger.warning( 'Slow query: %s\\nParameters: %s\\nDuration: %fs\\nContext:","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","# loaded modules. # - If the __file__ attribute on","is presented # in the table columns = [ #","edit , put book data :param id: :return: \"\"\" form","books = BookMain.get_all_book() # return render_template('book/list_book.html',books=books) @book.route(\"/list\") def list_book(): \"\"\"List","is : {booksn}\") temp = get_hackmdmeta(booksn) # print(temp) form.body.data =","searching the date # will search a date formatted equal","@book.route('/', methods=['GET', 'POST']) def index(): # books=BookMain.get_all_book() query = BookMain.query","get_debug_queries(): if query.duration >= current_app.config['PROJECT_SLOW_DB_QUERY_TIME']: current_app.logger.warning( 'Slow query: %s\\nParameters: %s\\nDuration:","book.keepsite = form.keepsite.data db.session.add(book) db.session.commit() flash('Your book data has been","table columns = [ # ColumnDT(cast(BookMain.id, db.Integer)), ColumnDT(BookMain.id), ColumnDT(BookMain.isbn), ColumnDT(BookMain.title_short),","= [ # ColumnDT(cast(BookMain.id, db.Integer)), ColumnDT(BookMain.id), ColumnDT(BookMain.isbn), ColumnDT(BookMain.title_short), ColumnDT(BookMain.title), ColumnDT(BookMain.catalogue),","book.cutter form.pub_year.data = book.pub_year form.copy_info.data = book.copy_info form.get_link.data = book.get_link","EditBookForm() book = BookMain.query.filter_by(id=id).first_or_404() if form.validate_on_submit(): # book.id = form.id.data","is : {id}\") form = EditBookForm() if form.validate_on_submit(): book.id =","\"\"\"List users with DataTables <= 1.10.x.\"\"\" return render_template('book/list_book.html') @book.route('/data', methods=['GET',","bugs that can't be fixed here: # - synopsis() cannot","= book.catalogue form.cutter.data = book.cutter form.pub_year.data = book.pub_year form.copy_info.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),",":return: \"\"\" book = BookMain.query.all() id = int(book[-1].id) + 1","book.removed form.keepsite.data = book.keepsite return render_template('book/edit_book.html', form=form) @book.route('/del/<int:id>', methods=['GET', 'POST'])","purpose query = db.session.query().select_from(BookMain) # GET parameters params = request.args.to_dict()","\"\"\" example.py ~~~~~~~~~ A simple command line application to run","flash('Your book data has been updated.', 'success') # return redirect(url_for('book.hackmd_meta'))","line application to run flask apps. :copyright: 2019 Miller :license:","DataTables(params, query, columns) # returns what is needed by DataTable","id return render_template('book/edit_book.html', form=form) @book.route('/edit/<int:id>', methods=['GET', 'POST']) def edit_book(id): \"\"\"","form.id.data = book.id form.isbn.data = book.isbn form.title_short.data = book.title_short form.title.data","render_template, redirect, request, url_for, flash,jsonify,current_app from flask_login import login_user, logout_user,","and table needed rowTable = DataTables(params, query, columns) # returns","flash('Your book data has been updated.', 'success') return redirect(url_for('book.index')) form.id.data","'POST']) # def list_book(): # \"\"\" # # :param field:","def get_book(): return f\"Hello book index : {id}\" @book.route('/post/', methods=['GET',","if form.validate_on_submit(): booksn = str(form.booksn.data) # print(f\"booksn is : {booksn}\")","needed rowTable = DataTables(params, query, columns) # returns what is","methods=['GET', 'POST']) def data(): \"\"\"Return server side data.\"\"\" # defining","ColumnDT, DataTables from .. import auth from .. import db","Book from booktags.flaskapp.model.models import BookMain # --------------------------------------------------------- common routines @book.after_app_request","returns what is needed by DataTable return jsonify(rowTable.output_result()) @book.route('/get/<int:id>', methods=['GET',","# return redirect(url_for('book.hackmd_meta')) return render_template('book/hackmd_meta.html',form=form) if __name__ == '__main__': pass","= request.args.to_dict() # instantiating a DataTable for the query and","form = EditBookForm() book = BookMain.query.filter_by(id=id).first_or_404() if form.validate_on_submit(): # book.id","BookMain.query page = request.args.get('page', 1, type=int) pagination = query.order_by(cast(BookMain.id, db.Integer)).paginate(","cannot be prevented from clobbering existing # loaded modules. #","@book.route('/get/<int:id>', methods=['GET', 'POST']) def get_book(): return f\"Hello book index :","here: # - synopsis() cannot be prevented from clobbering existing","# book.id = form.id.data book.isbn = form.isbn.data book.title_short = form.title_short.data","DataTable for the query and table needed rowTable = DataTables(params,","book.note form.reprint.data = book.reprint form.removed.data = book.removed form.keepsite.data = book.keepsite","renew query # \"\"\" # books = BookMain.get_all_book() # return","form.reprint.data = book.reprint form.removed.data = book.removed form.keepsite.data = book.keepsite return","columns) # returns what is needed by DataTable return jsonify(rowTable.output_result())","loaded modules. # - If the __file__ attribute on a","query.duration, query.context)) return response @book.route('/', methods=['GET', 'POST']) def index(): #","Miller :license: BSD-3-Clause \"\"\" # Known bugs that can't be"],"string":"[\n \"from datatables import ColumnDT, DataTables from .. import auth from\",\n \": {id}\\\" @book.route('/post/', methods=['GET', 'POST']) def post_book(): \\\"\\\"\\\" post new\",\n \"= int(book[-1].id) + 1 print(f\\\"id is : {id}\\\") form =\",\n \"be displayed. from flask import render_template, redirect, request, url_for, flash,jsonify,current_app\",\n \"from flask import render_template, redirect, request, url_for, flash,jsonify,current_app from flask_login\",\n \"# GET parameters params = request.args.to_dict() # instantiating a DataTable\",\n \"col name # :param order: asc or desc # :return:\",\n \"auth from .. import db from .forms import EditBookForm, HackmdMeta\",\n \"form.removed.data book.keepsite = form.keepsite.data db.session.add(book) db.session.commit() flash('Your book data has\",\n \"db from .forms import EditBookForm, HackmdMeta # from booktags.db.basemodels import\",\n \"%s\\\\nParameters: %s\\\\nDuration: %fs\\\\nContext: %s\\\\n' % (query.statement, query.parameters, query.duration, query.context)) return\",\n \"- explicitly cast date to string, so string searching the\",\n \"import login_user, logout_user, login_required, current_user from . import book from\",\n \"-*- \\\"\\\"\\\" example.py ~~~~~~~~~ A simple command line application to\",\n \"# ColumnDT(BookMain.reprint), # ColumnDT(BookMain.removed), # ColumnDT(BookMain.keepsite) ] # defining the\",\n \"import EditBookForm, HackmdMeta # from booktags.db.basemodels import Book from booktags.flaskapp.model.models\",\n \"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 = form.title.data book.catalogue = form.catalogue.data book.cutter = form.cutter.data\",\n \"= book.copy_info form.get_link.data = book.get_link form.note.data = book.note form.reprint.data =\",\n \"form.title.data = book.title form.catalogue.data = book.catalogue form.cutter.data = book.cutter form.pub_year.data\",\n \"form.catalogue.data = book.catalogue form.cutter.data = book.cutter form.pub_year.data = book.pub_year form.copy_info.data\",\n \"%fs\\\\nContext: %s\\\\n' % (query.statement, query.parameters, query.duration, query.context)) return response @book.route('/',\",\n \"data has been updated.', 'success') return redirect(url_for('book.index')) form.id.data = book.id\",\n \"import auth from .. import db from .forms import EditBookForm,\",\n \"# \\\"\\\"\\\" # # :param field: col name # :param\",\n \"response @book.route('/', methods=['GET', 'POST']) def index(): # books=BookMain.get_all_book() query =\",\n \"in the table columns = [ # ColumnDT(cast(BookMain.id, db.Integer)), ColumnDT(BookMain.id),\",\n \"# ColumnDT(BookMain.removed), # ColumnDT(BookMain.keepsite) ] # defining the initial query\",\n \"book.removed = form.removed.data book.keepsite = form.keepsite.data db.session.add(book) db.session.commit() flash('Your book\",\n \"is a relative path and # the current directory is\",\n \"db.session.commit() flash('Your book data has been updated.', 'success') return redirect(url_for('book.index'))\",\n \"book.pub_year form.copy_info.data = book.copy_info form.get_link.data = book.get_link form.note.data = book.note\",\n \"form.catalogue.data book.cutter = form.cutter.data book.pub_year = form.pub_year.data book.copy_info = form.copy_info.data\",\n \"form.keepsite.data = book.keepsite return render_template('book/edit_book.html', form=form) @book.route('/del/<int:id>', methods=['GET', 'POST']) def\",\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),\",\n \"instantiating a DataTable for the query and table needed rowTable\",\n \"equal to how it is presented # in the table\",\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\",\n \"book data :param id: :return: \\\"\\\"\\\" form = EditBookForm() book\",\n \"\\\"\\\"\\\" from booktags.vendor.hackmd_meta import get_hackmdmeta form = HackmdMeta() if form.validate_on_submit():\",\n \"% (query.statement, query.parameters, query.duration, query.context)) return response @book.route('/', methods=['GET', 'POST'])\",\n \":return: renew query # \\\"\\\"\\\" # books = BookMain.get_all_book() #\",\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\",\n \"users with DataTables <= 1.10.x.\\\"\\\"\\\" return render_template('book/list_book.html') @book.route('/data', methods=['GET', 'POST'])\",\n \"return jsonify(rowTable.output_result()) @book.route('/get/<int:id>', methods=['GET', 'POST']) def get_book(): return f\\\"Hello book\",\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 =\",\n \"= book.pub_year form.copy_info.data = book.copy_info form.get_link.data = book.get_link form.note.data =\",\n \"query.parameters, query.duration, query.context)) return response @book.route('/', methods=['GET', 'POST']) def index():\",\n \"%s\\\\nDuration: %fs\\\\nContext: %s\\\\n' % (query.statement, query.parameters, query.duration, query.context)) return response\",\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),\",\n \"{id}\\\" @book.route('/hackmdmeta', methods=['GET', 'POST']) def hackmd_meta(): \\\"\\\"\\\" :return: \\\"\\\"\\\" from\",\n \"= db.session.query().select_from(BookMain) # GET parameters params = request.args.to_dict() # instantiating\",\n \"-*- coding: utf-8 -*- \\\"\\\"\\\" example.py ~~~~~~~~~ A simple command\",\n \"params = request.args.to_dict() # instantiating a DataTable for the query\",\n \"# :param order: asc or desc # :return: renew query\",\n \"return render_template('book/edit_book.html', form=form) @book.route('/edit/<int:id>', methods=['GET', 'POST']) def edit_book(id): \\\"\\\"\\\" edit\",\n \"datatables import ColumnDT, DataTables from .. import auth from ..\",\n \"can't be fixed here: # - synopsis() cannot be prevented\",\n \"# books=BookMain.get_all_book() query = BookMain.query page = request.args.get('page', 1, type=int)\",\n \"synopsis() cannot be prevented from clobbering existing # loaded modules.\",\n \"be fixed here: # - synopsis() cannot be prevented from\",\n \"field: col name # :param order: asc or desc #\",\n \"from booktags.db.basemodels import Book from booktags.flaskapp.model.models import BookMain # ---------------------------------------------------------\",\n \"search a date formatted equal to how it is presented\",\n \"module is a relative path and # the current directory\",\n \"f\\\"Hello book index : {id}\\\" @book.route('/post/', methods=['GET', 'POST']) def post_book():\",\n \"defining columns # - explicitly cast date to string, so\",\n \"# # :param field: col name # :param order: asc\",\n \"# instantiating a DataTable for the query and table needed\",\n \".. import auth from .. import db from .forms import\",\n \", put book data :param id: :return: \\\"\\\"\\\" form =\",\n \".. import db from .forms import EditBookForm, HackmdMeta # from\",\n \"book.title = form.title.data book.catalogue = form.catalogue.data book.cutter = form.cutter.data book.pub_year\",\n \"int(book[-1].id) + 1 print(f\\\"id is : {id}\\\") form = EditBookForm()\",\n \"= book.reprint form.removed.data = book.removed form.keepsite.data = book.keepsite return render_template('book/edit_book.html',\",\n \"book.reprint form.removed.data = book.removed form.keepsite.data = book.keepsite return render_template('book/edit_book.html', form=form)\",\n \"form.get_link.data book.note = form.note.data book.reprint = form.reprint.data book.removed = form.removed.data\",\n \":return: \\\"\\\"\\\" form = EditBookForm() book = BookMain.query.filter_by(id=id).first_or_404() if form.validate_on_submit():\",\n \"print(temp) form.body.data = temp # flash('Your book data has been\",\n \"run flask apps. :copyright: 2019 Miller :license: BSD-3-Clause \\\"\\\"\\\" #\",\n \":param id: :return: \\\"\\\"\\\" form = EditBookForm() book = BookMain.query.filter_by(id=id).first_or_404()\",\n \"your purpose query = db.session.query().select_from(BookMain) # GET parameters params =\",\n \": {booksn}\\\") temp = get_hackmdmeta(booksn) # print(temp) form.body.data = temp\",\n \"render_template('book/index.html',books=books,pagination=pagination) # @book.route('/list/', methods=['GET', 'POST']) # def list_book(): # \\\"\\\"\\\"\",\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'])\",\n \"data(): \\\"\\\"\\\"Return server side data.\\\"\\\"\\\" # defining columns # -\",\n \"updated.', 'success') return redirect(url_for('book.index')) form.id.data = book.id form.isbn.data = book.isbn\",\n \"booktags.flaskapp.model.models import BookMain # --------------------------------------------------------- common routines @book.after_app_request def after_request(response):\",\n \"string searching the date # will search a date formatted\",\n \"from sqlalchemy.sql.expression import cast from datatables import ColumnDT, DataTables from\",\n \"'success') # return redirect(url_for('book.hackmd_meta')) return render_template('book/hackmd_meta.html',form=form) if __name__ == '__main__':\",\n \"desc # :return: renew query # \\\"\\\"\\\" # books =\",\n \"index(): # books=BookMain.get_all_book() query = BookMain.query page = request.args.get('page', 1,\",\n \"from flask_login import login_user, logout_user, login_required, current_user from . import\",\n \"logout_user, login_required, current_user from . import book from flask_sqlalchemy import\",\n \"print(f\\\"booksn is : {booksn}\\\") temp = get_hackmdmeta(booksn) # print(temp) form.body.data\",\n \"get_debug_queries from sqlalchemy.sql.expression import cast from datatables import ColumnDT, DataTables\",\n \"edit_book(id): \\\"\\\"\\\" edit , put book data :param id: :return:\",\n \"\\\"\\\"\\\" form = EditBookForm() book = BookMain.query.filter_by(id=id).first_or_404() if form.validate_on_submit(): #\",\n \"methods=['GET', 'POST']) def post_book(): \\\"\\\"\\\" post new book entry :return:\",\n \"form.title.data book.catalogue = form.catalogue.data book.cutter = form.cutter.data book.pub_year = form.pub_year.data\",\n \"= form.title.data book.catalogue = form.catalogue.data book.cutter = form.cutter.data book.pub_year =\",\n \": {id}\\\") form = EditBookForm() if form.validate_on_submit(): book.id = form.id.data\",\n \"request, url_for, flash,jsonify,current_app from flask_login import login_user, logout_user, login_required, current_user\",\n \"from .forms import EditBookForm, HackmdMeta # from booktags.db.basemodels import Book\",\n \"BookMain # --------------------------------------------------------- common routines @book.after_app_request def after_request(response): for query\",\n \"index : {id}\\\" @book.route('/post/', methods=['GET', 'POST']) def post_book(): \\\"\\\"\\\" post\",\n \"def list_book(): # \\\"\\\"\\\" # # :param field: col name\",\n \"= HackmdMeta() if form.validate_on_submit(): booksn = str(form.booksn.data) # print(f\\\"booksn is\",\n \"ColumnDT(BookMain.get_link), # ColumnDT(BookMain.note), # ColumnDT(BookMain.reprint), # ColumnDT(BookMain.removed), # ColumnDT(BookMain.keepsite) ]\",\n \"book data has been updated.', 'success') return redirect(url_for('book.index')) form.id.data =\",\n \"(query.statement, query.parameters, query.duration, query.context)) return response @book.route('/', methods=['GET', 'POST']) def\",\n \"the table columns = [ # ColumnDT(cast(BookMain.id, db.Integer)), ColumnDT(BookMain.id), ColumnDT(BookMain.isbn),\",\n \"index: del {id}\\\" @book.route('/hackmdmeta', methods=['GET', 'POST']) def hackmd_meta(): \\\"\\\"\\\" :return:\",\n \"side data.\\\"\\\"\\\" # defining columns # - explicitly cast date\",\n \"be prevented from clobbering existing # loaded modules. # -\",\n \"- synopsis() cannot be prevented from clobbering existing # loaded\",\n \"on a module is a relative path and # the\",\n \"string, so string searching the date # will search a\",\n \"form.id.data book.isbn = form.isbn.data book.title_short = form.title_short.data book.title = form.title.data\",\n \"os.chdir(), an incorrect # path will be displayed. from flask\",\n \"query, columns) # returns what is needed by DataTable return\",\n \"the __file__ attribute on a module is a relative path\",\n \"= form.id.data book.isbn = form.isbn.data book.title_short = form.title_short.data book.title =\",\n \"'POST']) def data(): \\\"\\\"\\\"Return server side data.\\\"\\\"\\\" # defining columns\",\n \"form.body.data = temp # flash('Your book data has been updated.',\",\n \"flash,jsonify,current_app from flask_login import login_user, logout_user, login_required, current_user from .\",\n \"# ColumnDT(BookMain.get_link), # ColumnDT(BookMain.note), # ColumnDT(BookMain.reprint), # ColumnDT(BookMain.removed), # ColumnDT(BookMain.keepsite)\",\n \"BookMain.get_all_book() # return render_template('book/list_book.html',books=books) @book.route(\\\"/list\\\") def list_book(): \\\"\\\"\\\"List users with\",\n \"def hackmd_meta(): \\\"\\\"\\\" :return: \\\"\\\"\\\" from booktags.vendor.hackmd_meta import get_hackmdmeta form\",\n \"book.isbn = form.isbn.data book.title_short = form.title_short.data book.title = form.title.data book.catalogue\",\n \"form = EditBookForm() if form.validate_on_submit(): book.id = form.id.data book.isbn =\",\n \"the current directory is changed with os.chdir(), an incorrect #\",\n \"application to run flask apps. :copyright: 2019 Miller :license: BSD-3-Clause\",\n \"form.copy_info.data book.get_link = form.get_link.data book.note = form.note.data book.reprint = form.reprint.data\",\n \"book.isbn form.title_short.data = book.title_short form.title.data = book.title form.catalogue.data = book.catalogue\",\n \"with os.chdir(), an incorrect # path will be displayed. from\",\n \"date formatted equal to how it is presented # in\",\n \"ColumnDT(BookMain.note), # ColumnDT(BookMain.reprint), # ColumnDT(BookMain.removed), # ColumnDT(BookMain.keepsite) ] # defining\",\n \"del_book(id): return f\\\"Hello book index: del {id}\\\" @book.route('/hackmdmeta', methods=['GET', 'POST'])\",\n \"'POST']) def hackmd_meta(): \\\"\\\"\\\" :return: \\\"\\\"\\\" from booktags.vendor.hackmd_meta import get_hackmdmeta\",\n \"to how it is presented # in the table columns\",\n \"1.10.x.\\\"\\\"\\\" return render_template('book/list_book.html') @book.route('/data', methods=['GET', 'POST']) def data(): \\\"\\\"\\\"Return server\",\n \"form=form) @book.route('/edit/<int:id>', methods=['GET', 'POST']) def edit_book(id): \\\"\\\"\\\" edit , put\",\n \"~~~~~~~~~ A simple command line application to run flask apps.\",\n \"form.validate_on_submit(): booksn = str(form.booksn.data) # print(f\\\"booksn is : {booksn}\\\") temp\",\n \"from booktags.vendor.hackmd_meta import get_hackmdmeta form = HackmdMeta() if form.validate_on_submit(): booksn\",\n \"def index(): # books=BookMain.get_all_book() query = BookMain.query page = request.args.get('page',\",\n \"been updated.', 'success') # return redirect(url_for('book.hackmd_meta')) return render_template('book/hackmd_meta.html',form=form) if __name__\",\n \". import book from flask_sqlalchemy import get_debug_queries from sqlalchemy.sql.expression import\",\n \"ColumnDT(BookMain.removed), # ColumnDT(BookMain.keepsite) ] # defining the initial query depending\",\n \"= book.id form.isbn.data = book.isbn form.title_short.data = book.title_short form.title.data =\",\n \"= temp # flash('Your book data has been updated.', 'success')\",\n \"'POST']) def del_book(id): return f\\\"Hello book index: del {id}\\\" @book.route('/hackmdmeta',\",\n \"form.copy_info.data = book.copy_info form.get_link.data = book.get_link form.note.data = book.note form.reprint.data\",\n \"return render_template('book/list_book.html',books=books) @book.route(\\\"/list\\\") def list_book(): \\\"\\\"\\\"List users with DataTables <=\",\n \"def data(): \\\"\\\"\\\"Return server side data.\\\"\\\"\\\" # defining columns #\",\n \"= form.note.data book.reprint = form.reprint.data book.removed = form.removed.data book.keepsite =\",\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'],\",\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(\",\n \"= form.pub_year.data book.copy_info = form.copy_info.data book.get_link = form.get_link.data book.note =\",\n \"return render_template('book/index.html',books=books,pagination=pagination) # @book.route('/list/', methods=['GET', 'POST']) # def list_book(): #\",\n \"utf-8 -*- \\\"\\\"\\\" example.py ~~~~~~~~~ A simple command line application\",\n \"a relative path and # the current directory is changed\",\n \"cast from datatables import ColumnDT, DataTables from .. import auth\",\n \"book data has been added.', 'success') return redirect(url_for('book.index')) form.id.data =\",\n \"put book data :param id: :return: \\\"\\\"\\\" form = EditBookForm()\",\n \"# in the table columns = [ # ColumnDT(cast(BookMain.id, db.Integer)),\",\n \"if form.validate_on_submit(): # book.id = form.id.data book.isbn = form.isbn.data book.title_short\",\n \"book.note = form.note.data book.reprint = form.reprint.data book.removed = form.removed.data book.keepsite\",\n \"attribute on a module is a relative path and #\",\n \"# defining the initial query depending on your purpose query\",\n \"= book.removed form.keepsite.data = book.keepsite return render_template('book/edit_book.html', form=form) @book.route('/del/<int:id>', methods=['GET',\",\n \"temp # flash('Your book data has been updated.', 'success') #\",\n \"has been added.', 'success') return redirect(url_for('book.index')) form.id.data = id return\",\n \"--------------------------------------------------------- common routines @book.after_app_request def after_request(response): for query in get_debug_queries():\",\n \"If the __file__ attribute on a module is a relative\",\n \"1 print(f\\\"id is : {id}\\\") form = EditBookForm() if form.validate_on_submit():\",\n \"page = request.args.get('page', 1, type=int) pagination = query.order_by(cast(BookMain.id, db.Integer)).paginate( page,\",\n \"= form.title_short.data book.title = form.title.data book.catalogue = form.catalogue.data book.cutter =\",\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),\",\n \"@book.route('/list/', methods=['GET', 'POST']) # def list_book(): # \\\"\\\"\\\" # #\",\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)\",\n \"form = HackmdMeta() if form.validate_on_submit(): booksn = str(form.booksn.data) # print(f\\\"booksn\",\n \"= form.keepsite.data db.session.add(book) db.session.commit() flash('Your book data has been added.',\",\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\",\n \"book = BookMain.query.all() id = int(book[-1].id) + 1 print(f\\\"id is\",\n \"'POST']) def edit_book(id): \\\"\\\"\\\" edit , put book data :param\",\n \"form.note.data book.reprint = form.reprint.data book.removed = form.removed.data book.keepsite = form.keepsite.data\",\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',\",\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>',\",\n \"query in get_debug_queries(): if query.duration >= current_app.config['PROJECT_SLOW_DB_QUERY_TIME']: current_app.logger.warning( 'Slow query:\",\n \"error_out=False) books = pagination.items return render_template('book/index.html',books=books,pagination=pagination) # @book.route('/list/', methods=['GET', 'POST'])\",\n \"= id return render_template('book/edit_book.html', form=form) @book.route('/edit/<int:id>', methods=['GET', 'POST']) def edit_book(id):\",\n \"apps. :copyright: 2019 Miller :license: BSD-3-Clause \\\"\\\"\\\" # Known bugs\",\n \"flask_sqlalchemy import get_debug_queries from sqlalchemy.sql.expression import cast from datatables import\",\n \"book entry :return: \\\"\\\"\\\" book = BookMain.query.all() id = int(book[-1].id)\",\n \"has been updated.', 'success') return redirect(url_for('book.index')) form.id.data = book.id form.isbn.data\",\n \"Known bugs that can't be fixed here: # - synopsis()\",\n \"current directory is changed with os.chdir(), an incorrect # path\",\n \"table needed rowTable = DataTables(params, query, columns) # returns what\",\n \"GET parameters params = request.args.to_dict() # instantiating a DataTable for\",\n \"'success') return redirect(url_for('book.index')) form.id.data = book.id form.isbn.data = book.isbn form.title_short.data\",\n \"= BookMain.query page = request.args.get('page', 1, type=int) pagination = query.order_by(cast(BookMain.id,\",\n \"current_app.logger.warning( 'Slow query: %s\\\\nParameters: %s\\\\nDuration: %fs\\\\nContext: %s\\\\n' % (query.statement, query.parameters,\",\n \"\\\"\\\"\\\" # books = BookMain.get_all_book() # return render_template('book/list_book.html',books=books) @book.route(\\\"/list\\\") def\",\n \"# - synopsis() cannot be prevented from clobbering existing #\",\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,\",\n \"query.context)) return response @book.route('/', methods=['GET', 'POST']) def index(): # books=BookMain.get_all_book()\",\n \"form.isbn.data = book.isbn form.title_short.data = book.title_short form.title.data = book.title form.catalogue.data\",\n \"explicitly cast date to string, so string searching the date\",\n \"query depending on your purpose query = db.session.query().select_from(BookMain) # GET\",\n \"+ 1 print(f\\\"id is : {id}\\\") form = EditBookForm() if\",\n \"= EditBookForm() if form.validate_on_submit(): book.id = form.id.data book.isbn = form.isbn.data\",\n \"modules. # - If the __file__ attribute on a module\",\n \"book.title_short = form.title_short.data book.title = form.title.data book.catalogue = form.catalogue.data book.cutter\",\n \"'POST']) def post_book(): \\\"\\\"\\\" post new book entry :return: \\\"\\\"\\\"\",\n \"book index : {id}\\\" @book.route('/post/', methods=['GET', 'POST']) def post_book(): \\\"\\\"\\\"\",\n \"book.cutter = form.cutter.data book.pub_year = form.pub_year.data book.copy_info = form.copy_info.data book.get_link\",\n \":copyright: 2019 Miller :license: BSD-3-Clause \\\"\\\"\\\" # Known bugs that\",\n \"{booksn}\\\") temp = get_hackmdmeta(booksn) # print(temp) form.body.data = temp #\",\n \"<reponame>MagicSword/Booktags #!/usr/bin/env python3 # -*- coding: utf-8 -*- \\\"\\\"\\\" example.py\",\n \"form.isbn.data book.title_short = form.title_short.data book.title = form.title.data book.catalogue = form.catalogue.data\",\n \"f\\\"Hello book index: del {id}\\\" @book.route('/hackmdmeta', methods=['GET', 'POST']) def hackmd_meta():\",\n \"# ColumnDT(BookMain.note), # ColumnDT(BookMain.reprint), # ColumnDT(BookMain.removed), # ColumnDT(BookMain.keepsite) ] #\",\n \"#!/usr/bin/env python3 # -*- coding: utf-8 -*- \\\"\\\"\\\" example.py ~~~~~~~~~\",\n \"BSD-3-Clause \\\"\\\"\\\" # Known bugs that can't be fixed here:\",\n \"= BookMain.query.filter_by(id=id).first_or_404() if form.validate_on_submit(): # book.id = form.id.data book.isbn =\",\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),\",\n \"= form.cutter.data book.pub_year = form.pub_year.data book.copy_info = form.copy_info.data book.get_link =\",\n \"A simple command line application to run flask apps. :copyright:\",\n \"data :param id: :return: \\\"\\\"\\\" form = EditBookForm() book =\",\n \"form.keepsite.data db.session.add(book) db.session.commit() flash('Your book data has been added.', 'success')\",\n \"order: asc or desc # :return: renew query # \\\"\\\"\\\"\",\n \"import render_template, redirect, request, url_for, flash,jsonify,current_app from flask_login import login_user,\",\n \"render_template('book/list_book.html',books=books) @book.route(\\\"/list\\\") def list_book(): \\\"\\\"\\\"List users with DataTables <= 1.10.x.\\\"\\\"\\\"\",\n \"post new book entry :return: \\\"\\\"\\\" book = BookMain.query.all() id\",\n \"book data has been updated.', 'success') # return redirect(url_for('book.hackmd_meta')) return\",\n \"flash('Your book data has been added.', 'success') return redirect(url_for('book.index')) form.id.data\",\n \"= book.cutter form.pub_year.data = book.pub_year form.copy_info.data = book.copy_info form.get_link.data =\",\n \"relative path and # the current directory is changed with\",\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'\",\n \"form.cutter.data = book.cutter form.pub_year.data = book.pub_year form.copy_info.data = book.copy_info form.get_link.data\",\n \"book.id = form.id.data book.isbn = form.isbn.data book.title_short = form.title_short.data book.title\",\n \"= EditBookForm() book = BookMain.query.filter_by(id=id).first_or_404() if form.validate_on_submit(): # book.id =\",\n \"db.session.add(book) db.session.commit() flash('Your book data has been updated.', 'success') return\",\n \">= current_app.config['PROJECT_SLOW_DB_QUERY_TIME']: current_app.logger.warning( 'Slow query: %s\\\\nParameters: %s\\\\nDuration: %fs\\\\nContext: %s\\\\n' %\",\n \"jsonify(rowTable.output_result()) @book.route('/get/<int:id>', methods=['GET', 'POST']) def get_book(): return f\\\"Hello book index\",\n \"from .. import auth from .. import db from .forms\",\n \"data has been added.', 'success') return redirect(url_for('book.index')) form.id.data = id\",\n \"query = BookMain.query page = request.args.get('page', 1, type=int) pagination =\",\n \"prevented from clobbering existing # loaded modules. # - If\",\n \"# def list_book(): # \\\"\\\"\\\" # # :param field: col\",\n \"# print(temp) form.body.data = temp # flash('Your book data has\",\n \"\\\"\\\"\\\" :return: \\\"\\\"\\\" from booktags.vendor.hackmd_meta import get_hackmdmeta form = HackmdMeta()\",\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), #\",\n \"= form.get_link.data book.note = form.note.data book.reprint = form.reprint.data book.removed =\",\n \"@book.route('/data', methods=['GET', 'POST']) def data(): \\\"\\\"\\\"Return server side data.\\\"\\\"\\\" #\",\n \"query and table needed rowTable = DataTables(params, query, columns) #\",\n \"= form.copy_info.data book.get_link = form.get_link.data book.note = form.note.data book.reprint =\",\n \"] # defining the initial query depending on your purpose\",\n \"id = int(book[-1].id) + 1 print(f\\\"id is : {id}\\\") form\",\n \"been updated.', 'success') return redirect(url_for('book.index')) form.id.data = book.id form.isbn.data =\",\n \"that can't be fixed here: # - synopsis() cannot be\",\n \"sqlalchemy.sql.expression import cast from datatables import ColumnDT, DataTables from ..\",\n \"query: %s\\\\nParameters: %s\\\\nDuration: %fs\\\\nContext: %s\\\\n' % (query.statement, query.parameters, query.duration, query.context))\",\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), #\",\n \"directory is changed with os.chdir(), an incorrect # path will\",\n \"get_hackmdmeta(booksn) # print(temp) form.body.data = temp # flash('Your book data\",\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\",\n \"= DataTables(params, query, columns) # returns what is needed by\",\n \"with DataTables <= 1.10.x.\\\"\\\"\\\" return render_template('book/list_book.html') @book.route('/data', methods=['GET', 'POST']) def\",\n \"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')\",\n \"= book.note form.reprint.data = book.reprint form.removed.data = book.removed form.keepsite.data =\",\n \"# books = BookMain.get_all_book() # return render_template('book/list_book.html',books=books) @book.route(\\\"/list\\\") def list_book():\",\n \"= book.get_link form.note.data = book.note form.reprint.data = book.reprint form.removed.data =\",\n \"str(form.booksn.data) # print(f\\\"booksn is : {booksn}\\\") temp = get_hackmdmeta(booksn) #\",\n \"book index: del {id}\\\" @book.route('/hackmdmeta', methods=['GET', 'POST']) def hackmd_meta(): \\\"\\\"\\\"\",\n \"# return render_template('book/list_book.html',books=books) @book.route(\\\"/list\\\") def list_book(): \\\"\\\"\\\"List users with DataTables\",\n \"been added.', 'success') return redirect(url_for('book.index')) form.id.data = id return render_template('book/edit_book.html',\",\n \"needed by DataTable return jsonify(rowTable.output_result()) @book.route('/get/<int:id>', methods=['GET', 'POST']) def get_book():\",\n \"booksn = str(form.booksn.data) # print(f\\\"booksn is : {booksn}\\\") temp =\",\n \"= pagination.items return render_template('book/index.html',books=books,pagination=pagination) # @book.route('/list/', methods=['GET', 'POST']) # def\",\n \"form.validate_on_submit(): # book.id = form.id.data book.isbn = form.isbn.data book.title_short =\",\n \"an incorrect # path will be displayed. from flask import\",\n \"cast date to string, so string searching the date #\",\n \"columns = [ # ColumnDT(cast(BookMain.id, db.Integer)), ColumnDT(BookMain.id), ColumnDT(BookMain.isbn), ColumnDT(BookMain.title_short), ColumnDT(BookMain.title),\",\n \"temp = get_hackmdmeta(booksn) # print(temp) form.body.data = temp # flash('Your\",\n \"formatted equal to how it is presented # in the\",\n \"from . import book from flask_sqlalchemy import get_debug_queries from sqlalchemy.sql.expression\",\n \"ColumnDT(BookMain.reprint), # ColumnDT(BookMain.removed), # ColumnDT(BookMain.keepsite) ] # defining the initial\",\n \"# Known bugs that can't be fixed here: # -\",\n \"login_required, current_user from . import book from flask_sqlalchemy import get_debug_queries\",\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\",\n \"methods=['GET', 'POST']) def del_book(id): return f\\\"Hello book index: del {id}\\\"\",\n \"def edit_book(id): \\\"\\\"\\\" edit , put book data :param id:\",\n \"= BookMain.get_all_book() # return render_template('book/list_book.html',books=books) @book.route(\\\"/list\\\") def list_book(): \\\"\\\"\\\"List users\",\n \"request.args.to_dict() # instantiating a DataTable for the query and table\",\n \"# print(f\\\"booksn is : {booksn}\\\") temp = get_hackmdmeta(booksn) # print(temp)\",\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>',\",\n \"\\\"\\\"\\\" edit , put book data :param id: :return: \\\"\\\"\\\"\",\n \"date # will search a date formatted equal to how\",\n \"# :param field: col name # :param order: asc or\",\n \"- If the __file__ attribute on a module is a\",\n \"form.reprint.data book.removed = form.removed.data book.keepsite = form.keepsite.data db.session.add(book) db.session.commit() flash('Your\",\n \"# will search a date formatted equal to how it\",\n \"asc or desc # :return: renew query # \\\"\\\"\\\" #\",\n \"redirect(url_for('book.index')) form.id.data = book.id form.isbn.data = book.isbn form.title_short.data = book.title_short\",\n \"DataTables from .. import auth from .. import db from\",\n \"changed with os.chdir(), an incorrect # path will be displayed.\",\n \"methods=['GET', 'POST']) def get_book(): return f\\\"Hello book index : {id}\\\"\",\n \"# flash('Your book data has been updated.', 'success') # return\",\n \"methods=['GET', 'POST']) # def list_book(): # \\\"\\\"\\\" # # :param\",\n \"# path will be displayed. from flask import render_template, redirect,\",\n \"will search a date formatted equal to how it is\",\n \"in get_debug_queries(): if query.duration >= current_app.config['PROJECT_SLOW_DB_QUERY_TIME']: current_app.logger.warning( 'Slow query: %s\\\\nParameters:\",\n \"form=form) @book.route('/del/<int:id>', methods=['GET', 'POST']) def del_book(id): return f\\\"Hello book index:\",\n \"{id}\\\") form = EditBookForm() if form.validate_on_submit(): book.id = form.id.data book.isbn\",\n \"defining the initial query depending on your purpose query =\",\n \"= book.title form.catalogue.data = book.catalogue form.cutter.data = book.cutter form.pub_year.data =\",\n \"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 updated.', 'success') # return redirect(url_for('book.hackmd_meta')) return render_template('book/hackmd_meta.html',form=form) if\",\n \"displayed. from flask import render_template, redirect, request, url_for, flash,jsonify,current_app from\",\n \"depending on your purpose query = db.session.query().select_from(BookMain) # GET parameters\",\n \"initial query depending on your purpose query = db.session.query().select_from(BookMain) #\",\n \"a date formatted equal to how it is presented #\",\n \"= book.keepsite return render_template('book/edit_book.html', form=form) @book.route('/del/<int:id>', methods=['GET', 'POST']) def del_book(id):\",\n \"get_hackmdmeta form = HackmdMeta() if form.validate_on_submit(): booksn = str(form.booksn.data) #\",\n \"print(f\\\"id is : {id}\\\") form = EditBookForm() if form.validate_on_submit(): book.id\",\n \"@book.route('/edit/<int:id>', methods=['GET', 'POST']) def edit_book(id): \\\"\\\"\\\" edit , put book\",\n \"id: :return: \\\"\\\"\\\" form = EditBookForm() book = BookMain.query.filter_by(id=id).first_or_404() if\",\n \"pagination.items return render_template('book/index.html',books=books,pagination=pagination) # @book.route('/list/', methods=['GET', 'POST']) # def list_book():\",\n \"incorrect # path will be displayed. from flask import render_template,\",\n \"book from flask_sqlalchemy import get_debug_queries from sqlalchemy.sql.expression import cast from\",\n \"db.session.add(book) db.session.commit() flash('Your book data has been added.', 'success') return\",\n \"book.get_link = form.get_link.data book.note = form.note.data book.reprint = form.reprint.data book.removed\",\n \"\\\"\\\"\\\" # # :param field: col name # :param order:\",\n \"what is needed by DataTable return jsonify(rowTable.output_result()) @book.route('/get/<int:id>', methods=['GET', 'POST'])\",\n \"example.py ~~~~~~~~~ A simple command line application to run flask\",\n \"post_book(): \\\"\\\"\\\" post new book entry :return: \\\"\\\"\\\" book =\",\n \"# defining columns # - explicitly cast date to string,\",\n \"list_book(): # \\\"\\\"\\\" # # :param field: col name #\",\n \"date to string, so string searching the date # will\",\n \"@book.route('/del/<int:id>', methods=['GET', 'POST']) def del_book(id): return f\\\"Hello book index: del\",\n \"'POST']) def get_book(): return f\\\"Hello book index : {id}\\\" @book.route('/post/',\",\n \"import get_hackmdmeta form = HackmdMeta() if form.validate_on_submit(): booksn = str(form.booksn.data)\",\n \"= form.reprint.data book.removed = form.removed.data book.keepsite = form.keepsite.data db.session.add(book) db.session.commit()\",\n \"routines @book.after_app_request def after_request(response): for query in get_debug_queries(): if query.duration\",\n \"get_book(): return f\\\"Hello book index : {id}\\\" @book.route('/post/', methods=['GET', 'POST'])\",\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',\",\n \"data.\\\"\\\"\\\" # defining columns # - explicitly cast date to\",\n \"from .. import db from .forms import EditBookForm, HackmdMeta #\",\n \"existing # loaded modules. # - If the __file__ attribute\",\n \"form.pub_year.data book.copy_info = form.copy_info.data book.get_link = form.get_link.data book.note = form.note.data\",\n \"book.catalogue = form.catalogue.data book.cutter = form.cutter.data book.pub_year = form.pub_year.data book.copy_info\",\n \"render_template('book/list_book.html') @book.route('/data', methods=['GET', 'POST']) def data(): \\\"\\\"\\\"Return server side data.\\\"\\\"\\\"\",\n \"DataTables <= 1.10.x.\\\"\\\"\\\" return render_template('book/list_book.html') @book.route('/data', methods=['GET', 'POST']) def data():\",\n \"EditBookForm, HackmdMeta # from booktags.db.basemodels import Book from booktags.flaskapp.model.models import\",\n \"book.title_short form.title.data = book.title form.catalogue.data = book.catalogue form.cutter.data = book.cutter\",\n \"__file__ attribute on a module is a relative path and\",\n \"import BookMain # --------------------------------------------------------- common routines @book.after_app_request def after_request(response): for\",\n \"= str(form.booksn.data) # print(f\\\"booksn is : {booksn}\\\") temp = get_hackmdmeta(booksn)\",\n \"on your purpose query = db.session.query().select_from(BookMain) # GET parameters params\",\n \"\\\"\\\"\\\" post new book entry :return: \\\"\\\"\\\" book = BookMain.query.all()\",\n \"flask apps. :copyright: 2019 Miller :license: BSD-3-Clause \\\"\\\"\\\" # Known\",\n \"= get_hackmdmeta(booksn) # print(temp) form.body.data = temp # flash('Your book\",\n \"def del_book(id): return f\\\"Hello book index: del {id}\\\" @book.route('/hackmdmeta', methods=['GET',\",\n \"= form.catalogue.data book.cutter = form.cutter.data book.pub_year = form.pub_year.data book.copy_info =\",\n \"coding: utf-8 -*- \\\"\\\"\\\" example.py ~~~~~~~~~ A simple command line\",\n \"simple command line application to run flask apps. :copyright: 2019\",\n \"so string searching the date # will search a date\",\n \"def post_book(): \\\"\\\"\\\" post new book entry :return: \\\"\\\"\\\" book\",\n \"db.session.commit() flash('Your book data has been added.', 'success') return redirect(url_for('book.index'))\",\n \"the query and table needed rowTable = DataTables(params, query, columns)\",\n \"clobbering existing # loaded modules. # - If the __file__\",\n \"= book.title_short form.title.data = book.title form.catalogue.data = book.catalogue form.cutter.data =\",\n \":license: BSD-3-Clause \\\"\\\"\\\" # Known bugs that can't be fixed\",\n \"HackmdMeta # from booktags.db.basemodels import Book from booktags.flaskapp.model.models import BookMain\",\n \"import cast from datatables import ColumnDT, DataTables from .. import\",\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\",\n \"# returns what is needed by DataTable return jsonify(rowTable.output_result()) @book.route('/get/<int:id>',\",\n \"= form.isbn.data book.title_short = form.title_short.data book.title = form.title.data book.catalogue =\",\n \"@book.route('/post/', methods=['GET', 'POST']) def post_book(): \\\"\\\"\\\" post new book entry\",\n \"command line application to run flask apps. :copyright: 2019 Miller\",\n \"return f\\\"Hello book index: del {id}\\\" @book.route('/hackmdmeta', methods=['GET', 'POST']) def\",\n \"url_for, flash,jsonify,current_app from flask_login import login_user, logout_user, login_required, current_user from\",\n \"# ColumnDT(BookMain.keepsite) ] # defining the initial query depending on\",\n \"for query in get_debug_queries(): if query.duration >= current_app.config['PROJECT_SLOW_DB_QUERY_TIME']: current_app.logger.warning( 'Slow\",\n \"return render_template('book/list_book.html') @book.route('/data', methods=['GET', 'POST']) def data(): \\\"\\\"\\\"Return server side\",\n \"import Book from booktags.flaskapp.model.models import BookMain # --------------------------------------------------------- common routines\",\n \"= form.removed.data book.keepsite = form.keepsite.data db.session.add(book) db.session.commit() flash('Your book data\",\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/',\",\n \"%s\\\\n' % (query.statement, query.parameters, query.duration, query.context)) return response @book.route('/', methods=['GET',\",\n \"server side data.\\\"\\\"\\\" # defining columns # - explicitly cast\",\n \"the initial query depending on your purpose query = db.session.query().select_from(BookMain)\",\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) #\",\n \"book.get_link form.note.data = book.note form.reprint.data = book.reprint form.removed.data = book.removed\",\n \"book.id form.isbn.data = book.isbn form.title_short.data = book.title_short form.title.data = book.title\",\n \"entry :return: \\\"\\\"\\\" book = BookMain.query.all() id = int(book[-1].id) +\",\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)\",\n \"path and # the current directory is changed with os.chdir(),\",\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\",\n \"common routines @book.after_app_request def after_request(response): for query in get_debug_queries(): if\",\n \"the date # will search a date formatted equal to\",\n \"# \\\"\\\"\\\" # books = BookMain.get_all_book() # return render_template('book/list_book.html',books=books) @book.route(\\\"/list\\\")\",\n \"updated.', 'success') # return redirect(url_for('book.hackmd_meta')) return render_template('book/hackmd_meta.html',form=form) if __name__ ==\",\n \"import get_debug_queries from sqlalchemy.sql.expression import cast from datatables import ColumnDT,\",\n \"data has been updated.', 'success') # return redirect(url_for('book.hackmd_meta')) return render_template('book/hackmd_meta.html',form=form)\",\n \".forms import EditBookForm, HackmdMeta # from booktags.db.basemodels import Book from\",\n \"python3 # -*- coding: utf-8 -*- \\\"\\\"\\\" example.py ~~~~~~~~~ A\",\n \"form.title_short.data = book.title_short form.title.data = book.title form.catalogue.data = book.catalogue form.cutter.data\",\n \"# --------------------------------------------------------- common routines @book.after_app_request def after_request(response): for query in\",\n \"HackmdMeta() if form.validate_on_submit(): booksn = str(form.booksn.data) # print(f\\\"booksn is :\",\n \"it is presented # in the table columns = [\",\n \"del {id}\\\" @book.route('/hackmdmeta', methods=['GET', 'POST']) def hackmd_meta(): \\\"\\\"\\\" :return: \\\"\\\"\\\"\",\n \":param order: asc or desc # :return: renew query #\",\n \"login_user, logout_user, login_required, current_user from . import book from flask_sqlalchemy\",\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 \"for the query and table needed rowTable = DataTables(params, query,\",\n \"query # \\\"\\\"\\\" # books = BookMain.get_all_book() # return render_template('book/list_book.html',books=books)\",\n \"books = pagination.items return render_template('book/index.html',books=books,pagination=pagination) # @book.route('/list/', methods=['GET', 'POST']) #\",\n \"form.note.data = book.note form.reprint.data = book.reprint form.removed.data = book.removed form.keepsite.data\",\n \"form.get_link.data = book.get_link form.note.data = book.note form.reprint.data = book.reprint form.removed.data\",\n \"will be displayed. from flask import render_template, redirect, request, url_for,\",\n \"path will be displayed. from flask import render_template, redirect, request,\",\n \"book = BookMain.query.filter_by(id=id).first_or_404() if form.validate_on_submit(): # book.id = form.id.data book.isbn\",\n \"ColumnDT(BookMain.keepsite) ] # defining the initial query depending on your\",\n \"BookMain.query.all() id = int(book[-1].id) + 1 print(f\\\"id is : {id}\\\")\",\n \"list_book(): \\\"\\\"\\\"List users with DataTables <= 1.10.x.\\\"\\\"\\\" return render_template('book/list_book.html') @book.route('/data',\",\n \":param field: col name # :param order: asc or desc\",\n \"presented # in the table columns = [ # ColumnDT(cast(BookMain.id,\",\n \"book.pub_year = form.pub_year.data book.copy_info = form.copy_info.data book.get_link = form.get_link.data book.note\",\n \"query = db.session.query().select_from(BookMain) # GET parameters params = request.args.to_dict() #\",\n \"redirect, request, url_for, flash,jsonify,current_app from flask_login import login_user, logout_user, login_required,\",\n \"book.copy_info form.get_link.data = book.get_link form.note.data = book.note form.reprint.data = book.reprint\",\n \"a DataTable for the query and table needed rowTable =\",\n \"import ColumnDT, DataTables from .. import auth from .. import\",\n \"to string, so string searching the date # will search\",\n \"current_user from . import book from flask_sqlalchemy import get_debug_queries from\",\n \"# from booktags.db.basemodels import Book from booktags.flaskapp.model.models import BookMain #\",\n \"ColumnDT(BookMain.copy_info) # ColumnDT(BookMain.get_link), # ColumnDT(BookMain.note), # ColumnDT(BookMain.reprint), # ColumnDT(BookMain.removed), #\",\n \"added.', 'success') return redirect(url_for('book.index')) form.id.data = id return render_template('book/edit_book.html', form=form)\",\n \"# - If the __file__ attribute on a module is\",\n \"# -*- coding: utf-8 -*- \\\"\\\"\\\" example.py ~~~~~~~~~ A simple\",\n \":return: \\\"\\\"\\\" from booktags.vendor.hackmd_meta import get_hackmdmeta form = HackmdMeta() if\",\n \"methods=['GET', 'POST']) def hackmd_meta(): \\\"\\\"\\\" :return: \\\"\\\"\\\" from booktags.vendor.hackmd_meta import\",\n \"import book from flask_sqlalchemy import get_debug_queries from sqlalchemy.sql.expression import cast\",\n \"form.keepsite.data db.session.add(book) db.session.commit() flash('Your book data has been updated.', 'success')\",\n \"columns # - explicitly cast date to string, so string\",\n \"a module is a relative path and # the current\",\n \"return response @book.route('/', methods=['GET', 'POST']) def index(): # books=BookMain.get_all_book() query\",\n \"# :return: renew query # \\\"\\\"\\\" # books = BookMain.get_all_book()\",\n \"# - explicitly cast date to string, so string searching\",\n \"{id}\\\" @book.route('/post/', methods=['GET', 'POST']) def post_book(): \\\"\\\"\\\" post new book\",\n \"# @book.route('/list/', methods=['GET', 'POST']) # def list_book(): # \\\"\\\"\\\" #\",\n \"\\\"\\\"\\\"Return server side data.\\\"\\\"\\\" # defining columns # - explicitly\",\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) #\",\n \"book.copy_info = form.copy_info.data book.get_link = form.get_link.data book.note = form.note.data book.reprint\",\n \"EditBookForm() if form.validate_on_submit(): book.id = form.id.data book.isbn = form.isbn.data book.title_short\",\n \"book.reprint = form.reprint.data book.removed = form.removed.data book.keepsite = form.keepsite.data db.session.add(book)\",\n \"booktags.vendor.hackmd_meta import get_hackmdmeta form = HackmdMeta() if form.validate_on_submit(): booksn =\",\n \"\\\"\\\"\\\" book = BookMain.query.all() id = int(book[-1].id) + 1 print(f\\\"id\",\n \"from clobbering existing # loaded modules. # - If the\",\n \"= form.keepsite.data db.session.add(book) db.session.commit() flash('Your book data has been updated.',\",\n \"is needed by DataTable return jsonify(rowTable.output_result()) @book.route('/get/<int:id>', methods=['GET', 'POST']) def\",\n \"@book.after_app_request def after_request(response): for query in get_debug_queries(): if query.duration >=\",\n \"<= 1.10.x.\\\"\\\"\\\" return render_template('book/list_book.html') @book.route('/data', methods=['GET', 'POST']) def data(): \\\"\\\"\\\"Return\",\n \"flask import render_template, redirect, request, url_for, flash,jsonify,current_app from flask_login import\",\n \"db.session.query().select_from(BookMain) # GET parameters params = request.args.to_dict() # instantiating a\",\n \"new book entry :return: \\\"\\\"\\\" book = BookMain.query.all() id =\",\n \"book.title form.catalogue.data = book.catalogue form.cutter.data = book.cutter form.pub_year.data = book.pub_year\",\n \"methods=['GET', 'POST']) def index(): # books=BookMain.get_all_book() query = BookMain.query page\",\n \"or desc # :return: renew query # \\\"\\\"\\\" # books\",\n \"\\\"\\\"\\\" # Known bugs that can't be fixed here: #\",\n \"fixed here: # - synopsis() cannot be prevented from clobbering\",\n \"to run flask apps. :copyright: 2019 Miller :license: BSD-3-Clause \\\"\\\"\\\"\",\n \"DataTable return jsonify(rowTable.output_result()) @book.route('/get/<int:id>', methods=['GET', 'POST']) def get_book(): return f\\\"Hello\",\n \"import db from .forms import EditBookForm, HackmdMeta # from booktags.db.basemodels\",\n \"= book.isbn form.title_short.data = book.title_short form.title.data = book.title form.catalogue.data =\",\n \"def after_request(response): for query in get_debug_queries(): if query.duration >= current_app.config['PROJECT_SLOW_DB_QUERY_TIME']:\",\n \"books=BookMain.get_all_book() query = BookMain.query page = request.args.get('page', 1, type=int) pagination\",\n \"name # :param order: asc or desc # :return: renew\",\n \"rowTable = DataTables(params, query, columns) # returns what is needed\",\n \"'POST']) def index(): # books=BookMain.get_all_book() query = BookMain.query page =\",\n \"return redirect(url_for('book.index')) form.id.data = book.id form.isbn.data = book.isbn form.title_short.data =\",\n \"methods=['GET', 'POST']) def edit_book(id): \\\"\\\"\\\" edit , put book data\",\n \"by DataTable return jsonify(rowTable.output_result()) @book.route('/get/<int:id>', methods=['GET', 'POST']) def get_book(): return\",\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\",\n \"and # the current directory is changed with os.chdir(), an\",\n \"2019 Miller :license: BSD-3-Clause \\\"\\\"\\\" # Known bugs that can't\",\n \"if form.validate_on_submit(): book.id = form.id.data book.isbn = form.isbn.data book.title_short =\",\n \"flask_login import login_user, logout_user, login_required, current_user from . import book\",\n \"from booktags.flaskapp.model.models import BookMain # --------------------------------------------------------- common routines @book.after_app_request def\",\n \"'Slow query: %s\\\\nParameters: %s\\\\nDuration: %fs\\\\nContext: %s\\\\n' % (query.statement, query.parameters, query.duration,\",\n \"ColumnDT(BookMain.cutter), ColumnDT(BookMain.pub_year), ColumnDT(BookMain.copy_info) # ColumnDT(BookMain.get_link), # ColumnDT(BookMain.note), # ColumnDT(BookMain.reprint), #\",\n \"parameters params = request.args.to_dict() # instantiating a DataTable for the\",\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\",\n \"hackmd_meta(): \\\"\\\"\\\" :return: \\\"\\\"\\\" from booktags.vendor.hackmd_meta import get_hackmdmeta form =\",\n \"booktags.db.basemodels import Book from booktags.flaskapp.model.models import BookMain # --------------------------------------------------------- common\",\n \"# the current directory is changed with os.chdir(), an incorrect\",\n \"render_template('book/edit_book.html', form=form) @book.route('/edit/<int:id>', methods=['GET', 'POST']) def edit_book(id): \\\"\\\"\\\" edit ,\",\n \"@book.route('/hackmdmeta', methods=['GET', 'POST']) def hackmd_meta(): \\\"\\\"\\\" :return: \\\"\\\"\\\" from booktags.vendor.hackmd_meta\",\n \"= BookMain.query.all() id = int(book[-1].id) + 1 print(f\\\"id is :\",\n \"return f\\\"Hello book index : {id}\\\" @book.route('/post/', methods=['GET', 'POST']) def\",\n \"@book.route(\\\"/list\\\") def list_book(): \\\"\\\"\\\"List users with DataTables <= 1.10.x.\\\"\\\"\\\" return\",\n \"how it is presented # in the table columns =\",\n \"is changed with os.chdir(), an incorrect # path will be\",\n \"if query.duration >= current_app.config['PROJECT_SLOW_DB_QUERY_TIME']: current_app.logger.warning( 'Slow query: %s\\\\nParameters: %s\\\\nDuration: %fs\\\\nContext:\",\n \"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\",\n \"# loaded modules. # - If the __file__ attribute on\",\n \"is presented # in the table columns = [ #\",\n \"edit , put book data :param id: :return: \\\"\\\"\\\" form\",\n \"books = BookMain.get_all_book() # return render_template('book/list_book.html',books=books) @book.route(\\\"/list\\\") def list_book(): \\\"\\\"\\\"List\",\n \"is : {booksn}\\\") temp = get_hackmdmeta(booksn) # print(temp) form.body.data =\",\n \"searching the date # will search a date formatted equal\",\n \"@book.route('/', methods=['GET', 'POST']) def index(): # books=BookMain.get_all_book() query = BookMain.query\",\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:\",\n \"book.keepsite = form.keepsite.data db.session.add(book) db.session.commit() flash('Your book data has been\",\n \"table columns = [ # ColumnDT(cast(BookMain.id, db.Integer)), ColumnDT(BookMain.id), ColumnDT(BookMain.isbn), ColumnDT(BookMain.title_short),\",\n \"= [ # ColumnDT(cast(BookMain.id, db.Integer)), ColumnDT(BookMain.id), ColumnDT(BookMain.isbn), ColumnDT(BookMain.title_short), ColumnDT(BookMain.title), ColumnDT(BookMain.catalogue),\",\n \"book.cutter form.pub_year.data = book.pub_year form.copy_info.data = book.copy_info form.get_link.data = book.get_link\",\n \"EditBookForm() book = BookMain.query.filter_by(id=id).first_or_404() if form.validate_on_submit(): # book.id = form.id.data\",\n \"is : {id}\\\") form = EditBookForm() if form.validate_on_submit(): book.id =\",\n \"\\\"\\\"\\\"List users with DataTables <= 1.10.x.\\\"\\\"\\\" return render_template('book/list_book.html') @book.route('/data', methods=['GET',\",\n \"bugs that can't be fixed here: # - synopsis() cannot\",\n \"= book.catalogue form.cutter.data = book.cutter form.pub_year.data = book.pub_year form.copy_info.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),\",\n \":return: \\\"\\\"\\\" book = BookMain.query.all() id = int(book[-1].id) + 1\",\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'])\",\n \"purpose query = db.session.query().select_from(BookMain) # GET parameters params = request.args.to_dict()\",\n \"\\\"\\\"\\\" example.py ~~~~~~~~~ A simple command line application to run\",\n \"flash('Your book data has been updated.', 'success') # return redirect(url_for('book.hackmd_meta'))\",\n \"line application to run flask apps. :copyright: 2019 Miller :license:\",\n \"DataTables(params, query, columns) # returns what is needed by DataTable\",\n \"id return render_template('book/edit_book.html', form=form) @book.route('/edit/<int:id>', methods=['GET', 'POST']) def edit_book(id): \\\"\\\"\\\"\",\n \"form.id.data = book.id form.isbn.data = book.isbn form.title_short.data = book.title_short form.title.data\",\n \"render_template, redirect, request, url_for, flash,jsonify,current_app from flask_login import login_user, logout_user,\",\n \"and table needed rowTable = DataTables(params, query, columns) # returns\",\n \"flash('Your book data has been updated.', 'success') return redirect(url_for('book.index')) form.id.data\",\n \"'POST']) # def list_book(): # \\\"\\\"\\\" # # :param field:\",\n \"def get_book(): return f\\\"Hello book index : {id}\\\" @book.route('/post/', methods=['GET',\",\n \"if form.validate_on_submit(): booksn = str(form.booksn.data) # print(f\\\"booksn is : {booksn}\\\")\",\n \"needed rowTable = DataTables(params, query, columns) # returns what is\",\n \"methods=['GET', 'POST']) def data(): \\\"\\\"\\\"Return server side data.\\\"\\\"\\\" # defining\",\n \"ColumnDT, DataTables from .. import auth from .. import db\",\n \"Book from booktags.flaskapp.model.models import BookMain # --------------------------------------------------------- common routines @book.after_app_request\",\n \"returns what is needed by DataTable return jsonify(rowTable.output_result()) @book.route('/get/<int:id>', methods=['GET',\",\n \"# return redirect(url_for('book.hackmd_meta')) return render_template('book/hackmd_meta.html',form=form) if __name__ == '__main__': pass\",\n \"= request.args.to_dict() # instantiating a DataTable for the query and\",\n \"form = EditBookForm() book = BookMain.query.filter_by(id=id).first_or_404() if form.validate_on_submit(): # book.id\",\n \"BookMain.query page = request.args.get('page', 1, type=int) pagination = query.order_by(cast(BookMain.id, db.Integer)).paginate(\",\n \"cannot be prevented from clobbering existing # loaded modules. #\",\n \"@book.route('/get/<int:id>', methods=['GET', 'POST']) def get_book(): return f\\\"Hello book index :\",\n \"here: # - synopsis() cannot be prevented from clobbering existing\",\n \"# book.id = form.id.data book.isbn = form.isbn.data book.title_short = form.title_short.data\",\n \"DataTable for the query and table needed rowTable = DataTables(params,\",\n \"book.note form.reprint.data = book.reprint form.removed.data = book.removed form.keepsite.data = book.keepsite\",\n \"renew query # \\\"\\\"\\\" # books = BookMain.get_all_book() # return\",\n \"form.reprint.data = book.reprint form.removed.data = book.removed form.keepsite.data = book.keepsite return\",\n \"columns) # returns what is needed by DataTable return jsonify(rowTable.output_result())\",\n \"loaded modules. # - If the __file__ attribute on a\",\n \"query.duration, query.context)) return response @book.route('/', methods=['GET', 'POST']) def index(): #\",\n \"Miller :license: BSD-3-Clause \\\"\\\"\\\" # Known bugs that can't be\"\n]","isConversational":false}}},{"rowIdx":2499,"cells":{"ngram":{"kind":"list like","value":["png = 'image/png' txt = 'text/plain; charset=us-ascii' json = 'application/json'","Enum class content_type(Enum): # https://www.iana.org/assignments/media-types/media-types.xhtml css = 'text/css' gif =","# https://www.iana.org/assignments/media-types/media-types.xhtml css = 'text/css' gif = 'image/gif' htm =","'image/jpeg' js = 'application/javascript' png = 'image/png' txt = 'text/plain;","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'","class content_type(Enum): # https://www.iana.org/assignments/media-types/media-types.xhtml css = 'text/css' gif = 'image/gif'","enum import Enum class content_type(Enum): # https://www.iana.org/assignments/media-types/media-types.xhtml css = 'text/css'","'image/jpeg' jpeg = 'image/jpeg' js = 'application/javascript' png = 'image/png'","= 'application/javascript' png = 'image/png' txt = 'text/plain; charset=us-ascii' json","https://www.iana.org/assignments/media-types/media-types.xhtml css = 'text/css' gif = 'image/gif' htm = 'text/html'","= 'text/css' gif = 'image/gif' htm = 'text/html' html =","txt = 'text/plain; charset=us-ascii' json = 'application/json' svg = 'image/svg+xml'","= 'image/png' txt = 'text/plain; charset=us-ascii' json = 'application/json' svg","'image/bmp' jpg = 'image/jpeg' jpeg = 'image/jpeg' js = 'application/javascript'","'text/html' html = 'text/html' ico = 'image/bmp' jpg = 'image/jpeg'","from enum import Enum class content_type(Enum): # https://www.iana.org/assignments/media-types/media-types.xhtml css =","'image/gif' htm = 'text/html' html = 'text/html' ico = 'image/bmp'","gif = 'image/gif' htm = 'text/html' html = 'text/html' ico","= 'image/jpeg' js = 'application/javascript' png = 'image/png' txt =","= 'text/html' ico = 'image/bmp' jpg = 'image/jpeg' jpeg =","'text/html' ico = 'image/bmp' jpg = 'image/jpeg' jpeg = 'image/jpeg'","'application/javascript' png = 'image/png' txt = 'text/plain; charset=us-ascii' json =","jpg = 'image/jpeg' jpeg = 'image/jpeg' js = 'application/javascript' png","'image/png' txt = 'text/plain; charset=us-ascii' json = 'application/json' svg =","= 'image/jpeg' jpeg = 'image/jpeg' js = 'application/javascript' png =","jpeg = 'image/jpeg' js = 'application/javascript' png = 'image/png' txt","html = 'text/html' ico = 'image/bmp' jpg = 'image/jpeg' jpeg","js = 'application/javascript' png = 'image/png' txt = 'text/plain; charset=us-ascii'","content_type(Enum): # https://www.iana.org/assignments/media-types/media-types.xhtml css = 'text/css' gif = 'image/gif' htm","css = 'text/css' gif = 'image/gif' htm = 'text/html' html","= 'image/bmp' jpg = 'image/jpeg' jpeg = 'image/jpeg' js =","= 'image/gif' htm = 'text/html' html = 'text/html' ico =","htm = 'text/html' html = 'text/html' ico = 'image/bmp' jpg","= 'text/html' html = 'text/html' ico = 'image/bmp' jpg =","ico = 'image/bmp' jpg = 'image/jpeg' jpeg = 'image/jpeg' js"],"string":"[\n \"png = 'image/png' txt = 'text/plain; charset=us-ascii' json = 'application/json'\",\n \"Enum class content_type(Enum): # https://www.iana.org/assignments/media-types/media-types.xhtml css = 'text/css' gif =\",\n \"# https://www.iana.org/assignments/media-types/media-types.xhtml css = 'text/css' gif = 'image/gif' htm =\",\n \"'image/jpeg' js = 'application/javascript' png = 'image/png' txt = 'text/plain;\",\n \"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'\",\n \"class content_type(Enum): # https://www.iana.org/assignments/media-types/media-types.xhtml css = 'text/css' gif = 'image/gif'\",\n \"enum import Enum class content_type(Enum): # https://www.iana.org/assignments/media-types/media-types.xhtml css = 'text/css'\",\n \"'image/jpeg' jpeg = 'image/jpeg' js = 'application/javascript' png = 'image/png'\",\n \"= 'application/javascript' png = 'image/png' txt = 'text/plain; charset=us-ascii' json\",\n \"https://www.iana.org/assignments/media-types/media-types.xhtml css = 'text/css' gif = 'image/gif' htm = 'text/html'\",\n \"= 'text/css' gif = 'image/gif' htm = 'text/html' html =\",\n \"txt = 'text/plain; charset=us-ascii' json = 'application/json' svg = 'image/svg+xml'\",\n \"= 'image/png' txt = 'text/plain; charset=us-ascii' json = 'application/json' svg\",\n \"'image/bmp' jpg = 'image/jpeg' jpeg = 'image/jpeg' js = 'application/javascript'\",\n \"'text/html' html = 'text/html' ico = 'image/bmp' jpg = 'image/jpeg'\",\n \"from enum import Enum class content_type(Enum): # https://www.iana.org/assignments/media-types/media-types.xhtml css =\",\n \"'image/gif' htm = 'text/html' html = 'text/html' ico = 'image/bmp'\",\n \"gif = 'image/gif' htm = 'text/html' html = 'text/html' ico\",\n \"= 'image/jpeg' js = 'application/javascript' png = 'image/png' txt =\",\n \"= 'text/html' ico = 'image/bmp' jpg = 'image/jpeg' jpeg =\",\n \"'text/html' ico = 'image/bmp' jpg = 'image/jpeg' jpeg = 'image/jpeg'\",\n \"'application/javascript' png = 'image/png' txt = 'text/plain; charset=us-ascii' json =\",\n \"jpg = 'image/jpeg' jpeg = 'image/jpeg' js = 'application/javascript' png\",\n \"'image/png' txt = 'text/plain; charset=us-ascii' json = 'application/json' svg =\",\n \"= 'image/jpeg' jpeg = 'image/jpeg' js = 'application/javascript' png =\",\n \"jpeg = 'image/jpeg' js = 'application/javascript' png = 'image/png' txt\",\n \"html = 'text/html' ico = 'image/bmp' jpg = 'image/jpeg' jpeg\",\n \"js = 'application/javascript' png = 'image/png' txt = 'text/plain; charset=us-ascii'\",\n \"content_type(Enum): # https://www.iana.org/assignments/media-types/media-types.xhtml css = 'text/css' gif = 'image/gif' htm\",\n \"css = 'text/css' gif = 'image/gif' htm = 'text/html' html\",\n \"= 'image/bmp' jpg = 'image/jpeg' jpeg = 'image/jpeg' js =\",\n \"= 'image/gif' htm = 'text/html' html = 'text/html' ico =\",\n \"htm = 'text/html' html = 'text/html' ico = 'image/bmp' jpg\",\n \"= 'text/html' html = 'text/html' ico = 'image/bmp' jpg =\",\n \"ico = 'image/bmp' jpg = 'image/jpeg' jpeg = 'image/jpeg' js\"\n]","isConversational":false}}}],"truncated":false,"partial":false},"paginationData":{"pageIndex":24,"numItemsPerPage":100,"numTotalItems":12866649,"offset":2400,"length":100}},"jwt":"eyJhbGciOiJFZERTQSJ9.eyJyZWFkIjp0cnVlLCJwZXJtaXNzaW9ucyI6eyJyZXBvLmNvbnRlbnQucmVhZCI6dHJ1ZX0sImlhdCI6MTc3NjM1NzI2MSwic3ViIjoiL2RhdGFzZXRzL3RlcnJ5eXovc3RhcmNvZGVyZGF0YV9uZ3JhbV8xMCIsImV4cCI6MTc3NjM2MDg2MSwiaXNzIjoiaHR0cHM6Ly9odWdnaW5nZmFjZS5jbyJ9.VhyzkbFZZFwc1pwsX2uivS7OAgqAwN2km5tpIfOoiaObzPblcE_vjV4K579VWutiNaO0BIb9zJLqJ4bdH4_fDQ","displayUrls":true,"splitSizeSummaries":[{"config":"default","split":"train","numRows":12866649,"numBytesParquet":126831957853}]},"discussionsStats":{"closed":0,"open":0,"total":0},"fullWidth":true,"hasGatedAccess":true,"hasFullAccess":true,"isEmbedded":false,"savedQueries":{"community":[],"user":[]}}">
ngram listlengths 0 82k |
|---|
[
"PyPI author=\"<NAME>\", author_email=\"<EMAIL>\", description=\"Soccer trajectory and event data generation\", keywords=\"soccer",
"setup, find_packages setup( name=\"soccergen\", version=\"0.1\", packages=find_packages(), # Project uses reStructuredText,",
"target machine install_requires=[\"gfootball>=2.8\",... |
[
"sm.engine.formula_parser import format_modifiers FDR_CONFIG = {'decoy_sample_size': 2} @patch('sm.engine.annotation.fdr.DECOY_ADDUCTS', ['+He', '+Li'])",
"= [(formula, adduct) for formula, adduct in product(formulas, target_adducts)] assert",
"decoy_sample_size) assert min_count < len(ions) <= max_count target... |
[] |
[
"learning, 2018 \"\"\" ub = 1 + ub lb =",
"= [] trends = [] for idx in range(len(price)-lookahead+1): arr_window",
"trading strategy and not a simple performance proxy. The rationale",
"if price[idx+lookahead-1] > price[idx]: coef = (price[idx+lookahead-1]-min(arr_window)) / (max(arr_window)-min(arr_window)) ... |
[
"None: output_filepath = create_image_cache_filename(input_filepath, *args, **kwargs) if os.path.exists(output_filepath): return output_filepath",
"convert(input_filepath, output_filepath=None, cleanup_files=False, mimetype=None, *args, **kwargs): size = kwargs.get('size') file_format",
"import OfficeConversion... |
[
"= plot_y * x_std[1] + x_mean[1] plot_data(x_mat, y, plot_x, plot_y)",
"frame.values x_mat = data[:, 0:2] # exam scores y =",
"/ theta[2]) * plot_x # denormalize the points plot_x =",
"theta2*x2 = 0 # x2 = -theta0 / theta2 -",
"% (45, 85, p[0, 0])) # Predict on train set",
"plot admitted plt.scatter(x_mat... |
[
").numpy() results_df = pd.DataFrame( data=results_dump, columns=[ \"epoch\", \"iteration\", \"processing_stats\", \"dataflow_stats\",",
"profiler.print_results(profiler.get_results()) trainer.run(dataloader, max_epochs=3) profiler.write_results('path_to_dir/time_profiling.csv') .. versionadded:: 0.4.6 \"\"\" EVE... |
[
"cycles DONE ! {datetime.now()}\") await asyncio.sleep(5) finally: # in every",
"for v in pmatrix_neglog.df.columns: # vertex source if v in",
"get: base_curr -- (sell_price - fee) --> quote_curr def __getitem__(self,",
"asyncio.sleep(5) finally: # in every case cancel the background task",
"the actual pair... |
[
"<<EMAIL>> # Creative Commons BY-NC-SA 4.0 International Public License #",
"LICENSE.md or https://creativecommons.org/licenses/by-nc-sa/4.0/) # \"\"\" The Snowtire binary sensor. For",
"# Copyright (c) 2020, Andrey \"Limych\" Khrolenok <<EMAIL>> # Creative",
"Snowtire binary sensor. For more details about th... |
[
"[-1.2, -1.8, -1.5], [ nan, 0.3, 0.5], [ nan, -1.3,",
"y_hat = model.predict_proba(X, n_jobs=2) y = [[ 9.85225968e-01, 1.47740317e-02], [",
"def test_bc_multivariate_gaussian_nan_predict(): y_hat = model.predict(X_nan) y = [0, 1, 1,",
"import with_setup from nose.tools import assert_almost_equal from nose.too... |
[
"dict): if config.get(\"VARIABLE_RANKING\"): output = VariableRanking(sol, base_kernel) else: output =",
"ImportError: print(\"Gurobi not found: error ignored to allow tests\") def",
"Solution, base_kernel: dict, config: dict): if config.get(\"VARIABLE_RANKING\"): output = VariableRanking(sol,",
"var_name): r... |
[
"of issues arising from PATH, sys.path, multiple Pythons, their interactions,",
"users suffer every time an entrypoint gets moved. To alleviate",
"'-m pip' instead of \" \"running pip directly.\\n\" ) return",
"for the current one. \"\"\" sys.stderr.write( \"WARNING: pip is being",
"avoid this problem you c... |
[
"= comment.replace('@doc-functions','') else: # Unwanted comment; skip. continue # Record",
"with custom header. # bb_lines = header_lines + Get_BB_Text(doc_lines) #",
"xml file. ''' # List of tuples of (label, text)",
"# Lua functions are in one lump, like overview. elif",
"'.lua': doc_lines += Get_Lua_Tex... |
[
"30 b = 17 print(\"Sum of a and b is\",a",
"two numbers a = 30 b = 17 print(\"Sum of",
"b = 17 print(\"Sum of a and b is\",a +",
"a = 30 b = 17 print(\"Sum of a and",
"= 17 print(\"Sum of a and b is\",a + b)",
"= 30 b = 17 print(\"Sum of a and b",
"#Addition of two numbers a = 30 b = 17",
"numbers a =... |
[
"= QLabel(self) self.l1.setText('Clique em um botao') self.l1.move(50, 50) self.l1.setStyleSheet('QLabel{font: bold;",
"self.carro = QLabel(self) self.carro.move(25, 200) self.carro.resize(450, 337) self.carro.setPixmap(QtGui.QPixmap('carro.jpg')) def gera_caixas_de_texto(self):",
"font-weight: 600}') botao2.cl... |
[
"height=\"{img_height}\" xlink:href=\"data:image/png;base64,{base64_data}\"/> </g> </svg>''' new_page_height += (img_height+10) svg += tmp_svg",
"/> <int name=\"ruleColor\" value=\"0\" /> <float name=\"marginLeft\" value=\"0\" /> <float",
"<float name=\"marginLeft\" value=\"0\" /> <float name=\"xOffset\" value=... |
[
"set_parameter_value(self, name: str, value: ParameterValueType): param = self.get_parameter(name) param.value =",
"' already added to this object') parameter = Parameter(name, value,",
"get_parameter(self, name: str) -> Parameter: for parameter in self.parameters: if",
"value_range: ParameterRangeType): if n... |
[
"a Region Of Interest, which may be either horizontal #",
"+ 1 def valid(self): return self.start >= 0 and self.start",
"- start + 1 def valid(self): return self.start >= 0",
"def crop(self, spectrum): return spectrum[self.start:self.end+1] def contains(self, value): return self.start",
"encapsulates a Regi... |
[
"0x3F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFC,",
"0xF0, 0xFA, 0x0F, 0xC6, 0x3F, 0x9F, 0xEC, 0x7E, 0x00, 0x00,",
"A PARTICULAR PURPOSE AND # NONINFRINGEMENT. IN NO EVENT SHALL",
"0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x60, 0x04,",
"0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,... |
[
".otsu import otsu_thresholding_method from .p_tile import p_tile_thresholding_method from .pun import",
".p_tile import p_tile_thresholding_method from .pun import pun_thresholding_method from .rosin import",
".gaussian import threshold_value_gaussian from .johannsen import johannsen_thresholding_method from .... |
[
"os.getenv('CELERY_RESULT_BACKEND', 'redis') CELERY_RESULT_BACKEND = os.getenv('CELERY_RESULT_BACKEND', 'amqp') ## Using the database",
"\"amqp://guest:guest@localhost:5672/\" #BROKER_URL = os.getenv('BROKER_URL', 'redis://guest@localhost:6379') #BROKER_HOST = \"localhost\" #BROKER_PORT =",
"= os.getenv('CELERY... |
[
"load client-secrets.json file ...\") secrets_file, cache_file = get_client_secret_filenames() sheets =",
"found\" if first is None else first[COL_DATE]) print(\"Last:\", \"<last> not",
"local_minutes = int(parts[1]) if half_it: local_hours = local_hours / 2",
"enable debug output\"\"\") print(\"\") print(\"T... |
[
"constants.FOLD # People who have gone all-in continue to be",
"max_bets[calls]) # Reset the bets and countdown current_bets[calls, player_idx] =",
"self.N_PLAYERS-1] = 0 if np.max(round_countdown[running_games]) <= 0: return current_bets, (round,",
"self.BIG_BLIND = BIG_BLIND self.logger = logger self.N_PLAY... |
[
"if obj.__class__ == Placeholder: placeholders[obj.pk] = obj if obj.__class__ ==",
"int(plugin.pk): plugin.set_base_attr(p) p.save() for old in current_plugins: if old.pk ==",
"created the placeholders/ get them instead try: placeholders[pk] = page.placeholders.get(slot=placeholder.slot)",
"obj): from reversi... |
[
"转化为int64 # print(label) label_gen_p = pd.DataFrame(label_gen_dict) label_gen_p.to_csv(gpath + 'label_delete.csv', index=False)",
"aa <= 40: print(aa) path, imagename = os.path.split(imagelist[aa]) im =",
"+ 'delete/' + 'idetail_' + imagename) gen_number += 1 label_dict",
"'label_delete.csv', index=False) # l... |
[
"中文字体 chFont = font_manager.FontProperties(family=\"SimHei\") # SimHei # chFont = font_manager.FontProperties(fname=\"C:/Windows/Fonts/SIMHEI.TTF\")",
"- - - - - - - - - -",
"range(60)] xLabels += [\"11点,{}分\".format(i) for i in range(60)] plt.xticks(list(x)[::step], xLabels[::step],",
"plt from matplotlib im... |
[
"data = dataset(\"clt\") canvas = regression.init() isoline = canvas.createisoline() isoline.label=\"y\"",
"dataset(\"clt\") canvas = regression.init() isoline = canvas.createisoline() isoline.label=\"y\" texts=[] colors",
"# Now set isoline.linecolors and test again. canvas.clear() isoline.linecolors =",
"is... |
[
"svm.SVC(kernel='linear'), \\ # random_state=None, n_estimators = 100 ) model =",
"y_pred_all[:, 0] target = y_pred_te y_pred = f_quantileNorm(templete, target) else:",
"y_pred = y_pred_te y_pred_all[:, i+1] = y_pred return y_pred_all #",
"[err_mat, models] = f_err_mat(X_tr, y_tr, clus, model) [dec_mat, dec_i... |
[
") parser.add_argument( '--synth_tiles', help='If using an ROI, synthetic tile defintion",
"( SELECT pkey FROM wire_in_tile WHERE name LIKE \"CLK_BUFG_REBUF_R_CK_GCLK%_BOT\" OR",
"types. \"\"\" cur = conn.cursor() cur.execute( \"\"\" SELECT pkey, tile_type_pkey,",
"FROM constant_sources') (track_pkey, ) = cur... |
[
"s = 4) cbar = f.colorbar(mlw, shrink=0.7) cbar.set_label(r'% recovered') f.savefig('./plots/'",
"[] for i, f in enumerate(files): print(round(i/len(files),4), f) fl =",
"NO crowding # New script copied from quest - want",
"for f in filters: m1hRec[f] = np.zeros_like(mbins)[1:] qhRec[f] = np.zeros_like(qbins)... |
[
"as cms import os process = cms.Process(\"summary\") process.MessageLogger = cms.Service(",
"#process.BeamSpotRcdPrinter.startIOV = 1354018504835073 #process.BeamSpotRcdPrinter.endIOV = 1374668707594734 ### 2018D Prompt #process.BeamSpotRcdPrinter.tagName",
"process.load(\"CondTools.BeamSpot.BeamSpotRcdPrinter_... |
[
"path from rest_framework_simplejwt.views import ( TokenObtainPairView, TokenRefreshView, TokenVerifyView ) urlpatterns",
"from django.urls import path from rest_framework_simplejwt.views import ( TokenObtainPairView, TokenRefreshView,",
"django.urls import path from rest_framework_simplejwt.views import ( Toke... |
[
"to view available # drive letters def __init__(self, host, port,",
"= 22 else: result['port'] = 21 # ftp port default",
"path = utf8_fix(path) if not self.exists(path): p = self.parent( path",
"= set(self.listdir(p)) return n in lst def isdir(self,path): path =",
"a directory generator # which first loads ... |
[
"[ 'C:\\\\Users\\\\Dude\\\\SomeFolder\\\\Chrome\\\\Default\\\\Extensions', ('C:\\\\Users\\\\Dude\\\\SomeNoneStandardFolder\\\\Chrome\\\\Default\\\\Extensions\\\\' 'hmjkmjkepdijhoojdojkdfohbdgmmhki'), ('C:\\\\Users\\\\frank\\\\AppData\\\\Local\\\\Google\\\\Chrome\\\\Extensions\\\\' 'blpcfgokakmgnkcojhhkbfbldkacnbeo'... |
[
"\"aa\", \"aaa\", \"aaaa\", \"aaaaa\", \"aaaaaa\", # \"aaaaaaa\", \"aaaaaaaa\", \"aaaaaaaaa\", \"aaaaaaaaaa\"]",
"= \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\" # words = [\"a\", \"aa\", \"aaa\", \"aaaa\... |
[
"update.call_count) update.reset_mock() for kwarg in expected_kwargs: kwarg['head'] = 'contract@head' self._main_test_helper(",
"sa.Column('organization_id', sa.Integer()) ), alembic_ops.CreateForeignKeyOp( 'org_fk', 'user', 'organization', ['organization_id'], ['id'] ),",
"'contract@head' self._main_test_helpe... |
[
"floor = initial_amount_inflation_adjusted * self.floor ceiling = initial_amount_inflation_adjusted * self.ceiling",
"= self.rate * self.portfolio.value initial_amount_inflation_adjusted = self.initial_amount * self.cumulative_inflation floor",
"def start(self): amount = self.rate * self.portfolio.value self.in... |
[
"dig_e1_e7 = self.i2c.readfrom_mem(self.address, 0xE1, 7) self.dig_T1, self.dig_T2, self.dig_T3, self.dig_P1, \\",
"h h = 419430400 if h > 419430400 else h",
"self._l8_barray raw_press = ((readout[0] << 16) | (readout[1] << 8)",
"0xF2 BME280_REGISTER_CONTROL = 0xF4 BME280_REGISTER_CONTROL_IIR = 0xF5 FILTER_OF... |
[
"super(VaultBackend, self).__init__() self.connections_path = connections_path.rstrip('/') if variables_path != None: self.variables_path",
"auth_type self.kwargs = kwargs self.token = token self.username = username",
"username=self.username, password=self.password) elif self.auth_type == \"userpass\": _client.... |
[
"items to raw document representation. 2. Converts the collection of",
"[x[1] for x in los1]) # Create bag of words",
"elapsed > 60: if total > 3600: print(f'(+{elapsed/60:.2f}m|t:{total/3600:.2f}h) {msg}') else:",
"between 0-1, with 1 being identical. \"\"\" if type(los1) ==",
"from local file lap(\"Loadin... |
[
"Move(uci=move.uci()), Board(array=array).legal_moves)) ) array[0, :] = Board.piece_symbol_to_int(\"p\") all_possible_moves.update( set(map(lambda move:",
"[\"Q\", \"N\"] ): array[i][j] = Board.piece_symbol_to_int(piece) all_possible_moves.update( set(map(lambda move: Move(uci=move.uci()),",
"array[1, :] = Boar... |
[
"self.y1 + scaled_effort # Don't let the vehcicle fall through",
"Args: effort (float): related to the upward thrust of the",
"<= 0 and net_acceleration < 0: y0dot = 0 y1dot",
"net_acceleration self.y0 += y0dot * self.dt self.y1 += y1dot *",
"self.y0 += gauss(0, self.noise) return self.y0, self.y1 def get_a... |
[
") -> Union[Dict[str, Any], List[Any]]: return self.request('delete', endpoint, data) def",
"SignatureValidationError, StpmexException, ) from .resources import CuentaFisica, Orden, Resource, Saldo",
"invalido', desc): raise InvalidField(**resp) elif id == 3 and desc",
"import UnsupportedAlgorithm from crypto... |
[
"l, ['1','2','3','4','7','8'] ) l -= \"2, 3\" self.assertEqual( l, ['1','4','7','8']",
") l += [7, 8] self.assertEqual( l, [1,2,3,4,7,8] ) l",
"[10,12] ) self.assertEqual( l, [10,12,1,4,7,8] ) l.extend( [0,-1] ) self.assertEqual(",
"\"10,12\" ) self.assertEqual( l, ['10','12','1','4','7','8'] ) l.extend( \"0,... |
[
"def log(self, file_object, email, log_message, log_writer_id): self.now = datetime.now() self.date",
"from src.utils import uploaded_file import os class App_Logger: def __init__(self):",
"from datetime import datetime from src.utils import uploaded_file import os",
"self.date = self.now.date() self.current_... |
[
"# name of meta root dir META_DIR = \".metasync\" #",
"Increase of Paxos proposal number PAXOS_PNUM_INC = 10 # authentication",
"params KB = 1024 MB = 1024*KB GB = 1024*MB",
"BLOB_UNIT = 32*MB # Increase of Paxos proposal number PAXOS_PNUM_INC",
"blob size BLOB_UNIT = 32*MB # Increase of Paxos proposal",
... |
[
"test(\"()[]{}\", result=True) test(\"(]\", result=False) test(\"([)]\", result=False) test(\"{[]}\", result=True) test(\"\", result=True)",
"unittest from py.tests.utils import test from py import valid_parentheses as",
"@test(vp.Solution.is_valid) def test_valid_parentheses(self) -> None: test(\"()\", result=... |
[
"inference on the image if self.model_type == ModelType.flyingthings: left_disparity, right_disparity",
"# Perform inference on the image if self.model_type == ModelType.flyingthings:",
"2) left_img = cv2.cvtColor(left_img, cv2.COLOR_BGR2GRAY) right_img = cv2.cvtColor(right_img, cv2.COLOR_BGR2GRAY) left_img",
... |
[
"\"Intercept\" # Group to which the plugin belongs to def",
"field_kwargs = { 'required': self.data.required, 'label': self.data.label, 'widget': forms.widgets.NumberInput(attrs={}), }",
"your current address?\" form = HouseholdTenureForm group = \"Intercept\" #",
"plugin belongs to def get_form_field_instanc... |
[
"<gh_stars>0 __all__ = ['EnemyBucketWithStar', 'Nut', 'Beam', 'Enemy', 'Friend', 'Hero', 'Launcher',",
"'Enemy', 'Friend', 'Hero', 'Launcher', 'Rotor', 'SpikeyBuddy', 'Star', 'Wizard', 'EnemyEquipedRotor', 'CyclingEnemyObject',",
"['EnemyBucketWithStar', 'Nut', 'Beam', 'Enemy', 'Friend', 'Hero', 'Launcher', 'Ro... |
[
"torch.nn.utils.rnn import pack_padded_sequence fine_tune_encoder = False # Read word map",
"errD ####################################################### # (3) Update G network: maximize log(D(G(z))) ######################################################",
"print('Load %s_%d.pth' % (cfg.TRAIN.NET_D, i)) state_d... |
[
"return template(\"error\", sporocilo=\"Stran ne obstaja!\", naslov=\"404\") @bottle.error(500) def napaka500(a): return",
"slovar_kolicin=slovar_kolicin) @bottle.error(404) def napaka404(a): return template(\"error\", sporocilo=\"Stran ne obstaja!\", naslov=\"404\")",
"dobi_parcele_za_prikaz, dobi_info_parcele... |
[
"initialize def initializer(model, args): \"\"\"Initialize transducer model. Args: model (torch.nn.Module):",
"coding: utf-8 -*- \"\"\"Parameter initialization for transducer RNN/Transformer parts.\"\"\" import",
"model.dec.embed.weight.data.normal_(0, 1) for l in six.moves.range(len(model.dec.decoder)): set_fo... |
[
"np.multiply( P.dot( model.P1 ).dot( backward_likelihood(i+1, trace) ), model.M[:, trace[i][1]] )",
"trace[i][1]] ) if likelihoods.sum() != 0: likelihoods = likelihoods /",
"backward_likelihood(i, trace): N = model.N M = len( trace )",
"= traces_factory.traces P0 = np.matrix(\"[ .02 0;\" \"0 0 0.5;\"",
"= n... |
[
"do not use this object directly. imageCanvas = vtk.vtkImageCanvasSource2D() imageCanvas.SetNumberOfScalarComponents(3)",
"imageCanvas.FillBox(100,150,0,100) imageCanvas.SetDrawColor(0,128,128) imageCanvas.FillBox(150,200,0,100) imageCanvas.SetDrawColor(0,0,255) imageCanvas.FillBox(200,250,0,100) imageCanvas.SetD... |
[
"with open('kelas_2b/echa.csv', 'r') as csvfile: csv_reader = csv.reader(csvfile, delimiter=',') for",
"= csv.reader(csvfile, delimiter=',') for row in csv_reader: print(\"menampilkan data barang:\",",
"for row in csv_reader: print(\"menampilkan data barang:\", row[0], row[1], row[2],",
"import csv class echa... |
[
"im_shape[0] - centre[0], -centre[1] : im_shape[1] - centre[1], -centre[2] :",
"2.0 (the \"License\"); # you may not use this file",
"import unittest from typing import Tuple import numpy as np",
"(99, 99, 99) ) -> np.ndarray: \"\"\" Return a 3D",
"[torch.Tensor(create_spherical_seg_3d(radius=20, centre=(10... |
[
"spec.get(\"novelty\", True) normal_classes = spec[\"normal_classes\"] precision = defaultdict(list) for rounds",
"specification missing from the command line arguments\") exit(1) spec_file =",
"= df.sample(n=max_rows, replace=False) label_col = spec[\"label_column\"] y = df[label_col].values other",
"X_train... |
[
"'install path': Path(__file__).resolve().parent, 'python version': sys.version, 'platform': platform.platform(), 'optional deps.",
"platform.platform(), 'optional deps. installed': optional_deps, } return '\\n'.join('{:>30} {}'.format(k +",
"= '1.4a1' def version_info() -> str: import platform import sys",
"... |
[
"subject.configuration: token = '/'.join(tokens) if dependency: structure = dependency.construct_schema(name=token) if",
"while queue: subject, tokens, dependency = queue.pop(0) if subject.configuration: token",
"= {} schemas = {} units = {} @classmethod def",
"def register_unit(cls, unit): cls.units[unit.ide... |
[
".messaging import * from .method import * from .operation import",
"import * from .database import * from .entrypoint import *",
"* from .method import * from .operation import * from",
"from .messaging import * from .method import * from .operation",
"import * from .operation import * from .stack import *... |
[
"= random.choice(range(len(tokens))) choice = \" \".join( tokens[phrase_index : min(len(tokens), phrase_index",
"target = f\"<s> {target}\" if args.add_eos: target = f\"{target} </s>\"",
"\"__main__\": parser = argparse.ArgumentParser() parser.add_argument(\"--number\", \"-n\", type=int, default=1, help=\"numbe... |
[
"<filename>AppImageBuilder/commands/file.py # Copyright 2020 <NAME> # # Permission is hereby",
"conditions: # # The above copyright notice and this permission",
"0: raise FileError('\\n'.join(self.stderr)) return '\\n'.join(self.stdout) def is_executable_elf(self, path): output =",
"permit persons to whom the... |
[
"other urls present on the records if --select-url is given.)\")",
"help=\"A file to filter urls by. Excludes urls with 'desc'",
"records: record_remove_urls_not_matching(record, pattern) # sort the records by id, to",
"{}, n: int): hosts = [h for h in hosts_to_urls.keys()",
"def record_get_urls_matching(re... |
[
"via pants via the portion of the spec following the",
"# # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law",
"the colon sources: A list of paths containing the Antlr",
"compiler used to compile the ANTLR files. Currently only supports",
"against. compiler: The name of the c... |
[
"def i_create_a_pca_from_dataset(step): dataset = world.dataset.get('resource') resource = world.api.create_pca(dataset, {'name': 'new",
"{'name': 'new PCA'}) world.status = resource['code'] eq_(world.status, HTTP_CREATED) world.location =",
"#@step(r'I create a PCA from a dataset$') def i_create_a_pca_from_dat... |
[
"'Back'] admins = ['admin1_telegram_nickname', 'admin2_telegram_nickname'] avail_days = [] TOKEN =",
"['admin1_telegram_nickname', 'admin2_telegram_nickname'] avail_days = [] TOKEN = 'bot_<PASSWORD>' group_id =",
"= '' options = ['Info', 'Check-in/Out', 'Edit games', 'Back'] admins",
"'Check-in/Out', 'Edit ga... |
[
"you like? (sourdough, rye, wheat, or white)\\n' bread_type = ip.inputChoice(['sourdough',",
"wheat, or white)\\n' bread_type = ip.inputChoice(['sourdough', 'rye', 'wheat', 'white'], prompt=bread_prompt)",
"of protein would you like? (chicken, turkey, ham, or tofu)\\n'",
"tomato, lettuce]) for item in sandwic... |
[
"Chapter from builder.containers.episode import Episode from builder.containers.scene import Scene from",
"SCmd.TAG_TITLE) self.assertEqual(tmp.script, expect) self.assertEqual(tmp.option, exp_opt) validate_with_fail(self, 'title_of', checker, data) def",
"expect): tmp = hd.HeaderUpdater()._outline_of(src) self... |
[
"np.False_]), np.array([np.True_, np.True_, np.False_])] f = h5py.File(filename, 'x') # create",
"rows[r] f.flush() f.close() f = h5py.File(filename, 'r') dsetr = f[\"vlen_matrix\"]",
"np.False_])] f = h5py.File(filename, 'x') # create file, fails if",
"= [np.array([np.True_, np.False_]), np.array([np.True_, ... |
[
"imVideo[vid].shape[2] # display video blnLoop = True fid = 0",
"= (fid + 1) % maxFrames else: if k ==",
"= cv2.resize(imDisp.copy(), None, fx=resizeAmount, fy=resizeAmount) imDisp = cv2.cvtColor(imDisp, cv2.COLOR_GRAY2RGB) if",
"fmt metadata['FORMAT'] = fmt vmode = vidseq.get(cv2.CAP_PROP_MODE) if vmode >",
... |
[
"= subject # smtp.sendmail() only converts CR and LF (produced",
"= address.split(\"@\", 1) return \"%s@%s\" % (local, domain.lower()) def send(mailto,",
"MIMEText(content.strip()) message[\"To\"] = mailto message[\"From\"] = macro.MACRO_EMAIL_ADDRESS message[\"Subject\"] = subject",
"given address is not con... |
[
"warning): app.builder.build_all() assert \"build succeeded\" not in status.getvalue() warnings =",
"\"build succeeded\" not in status.getvalue() warnings = warning.getvalue().strip() assert 'WARNING:",
"Requested child \"http://example.org/system/Missing\" of \"http://example.org/system/ErrorMissingProcess\" i... |
[
"if analysis=='Yes': levels=['Level 1','Level 2','Level 3'] #calculating the score of",
"bar chart plt.bar(levels,level_score,color='blue',edgecolor='black') plt.title('Levelwise Scores',fontsize=16)#add title plt.xlabel('Levels')#set x-axis label plt.ylabel('Scores')#set",
"unique values in array along with th... |
[
"= 'mspaint' # replace with another editor if Unix rootdir",
"in degrees vcen = (1,0,0) # x y z coords",
"2022 by <NAME> | | [<EMAIL>] | |-----------------------------------| | We",
"40 # height of cone deganglestep = 5 # how",
"= 0 # outline color rotation = rotvec3D(25,240,70) # rotation",
"cf = getRGBf... |
[
"+= 1 plt.scatter(rmse[:, 0], rmse[:, 1]) plt.yscale('log') plt.ylim([1e-3, 1e-1]) plt.xlim([0,",
"import sys sys.path.append(r'/home/andrewkirby72/phd_work/data_synthesis') from GP_machine_learning.GP_machine_learning_functions import * from regular_array_sampling.functions import",
"0 while n_train < 200: n_t... |
[
"the AC previously. The list is ordered chronologically, from newest",
"tquery import get_latest_record from config import * app = Flask(__name__)",
"== 'POST': # someone's logging in if not request.form['username'] in",
"= db_record[0].strftime(\"%H:%M\") out_record['celsius'] = db_record[1] out_record['fahr... |
[
"eigenvectors: np.ndarray) -> bool: \"\"\"Check that the eigenvalue equation holds.\"\"\"",
"matrix: np.ndarray, eigenvalues: np.ndarray, eigenvectors: np.ndarray) -> bool: \"\"\"Check that",
"return np.sqrt(np.dot(vs, vs)) def create_random_matrix(size: int) -> np.array: \"\"\"Create a",
"= create_random_mat... |
[
"nums[nums[i]], nums[i] = nums[i], nums[nums[i]] return -1 if __name__ ==",
"Solution: def findRepeatNumber(self, nums: List[int]) -> int: # solution one:",
"i in range(1, len(nums)): if pre == nums[i]: return nums[i]",
"def findRepeatNumber(self, nums: List[int]) -> int: # solution one: 哈希表",
"len(nums)): ... |
[
"GWUNetwork from gwu_nn.layers import Dense from gwu_nn.activation_layers import Sigmoid np.random.seed(8)",
"logit colors = ['red'] * num_obs + ['blue'] * num_obs",
"print(X.shape) y = np.hstack((np.zeros(num_obs), np.ones(num_obs))) print(y.shape) # colors = ['red']",
"we don't cheat X_train, X_test, y_trai... |
[
"get_form_factor(element_name=elem1.symbol, water=water) form_factor2 = get_form_factor(element_name=elem2.symbol, water=water) coeff = form_factor1 *",
"r : numpy.ndarray r positions generated by histogram binning g_r_t",
"import mdtraj as md from progressbar import ProgressBar from scattering.utils.utils",
... |
[
"import * from .quant_lenet5 import * from .quant_cnv import *",
"# nn_benchmark # author - <NAME> # https://github.com/QDucasse # <EMAIL>",
".alexnet import * from .lenet import * from .lenet5 import",
"* from .quant_alexnet import * from .quant_lenet5 import * from",
"* from .lenet5 import * from .mobilen... |
[
"cv.imshow('Gray', gray) # blur = cv.GaussianBlur(gray, (5,5), cv.BORDER_DEFAULT) cv.imshow('Blur', blur)",
"cv.COLOR_BGR2GRAY) cv.imshow('Gray', gray) # blur = cv.GaussianBlur(gray, (5,5), cv.BORDER_DEFAULT) cv.imshow('Blur',",
"canny = cv.Canny(blur, 125, 175) cv.imshow('Canny Edges', canny) # ret,",
"impor... |
[] |
[
"import Document class Practitioner(Document): def before_save(self): self.practitioner_full_name = f'{self.first_name} {self.second_name",
"license.txt # import frappe from frappe.model.document import Document class Practitioner(Document):",
"and contributors # For license information, please see license.txt ... |
[
"+ '/.git/config', 'a+') as gitConfig: if (\"[checkstyle]\" not in gitConfig.read()):",
"for pre-commit. Has to run as root, enter password plz\")",
"+ \"/.git/hooks/\" + checkstyleName) urlretrieve(checkstyleUrl, basePath + \"/.git/hooks/\" + checkstyleName)",
"gitConfig.write(\"jar = %s\\n\" % (basePath + \... |
[
"= {} # Set up the paths and environment for",
"for static pages. It is the default handler.\"\"\" # Build",
"the file then return an error to the client. try:",
"file_type data = open(file_path, 'rb').read() self.response.body_file.write(data) except Exception as e:",
"based on WebOb, Jinja2, WSGI with a s... |
[
"= set(UserProfile.objects.values_list('email', flat=True) # whoa .filter(addons__versions__files__jetpack_version__isnull=False)) log.info('There are %d emails",
"release candidate build - https://ftp.mozilla.org/pub/mozilla.org/labs/jetpack/addon-sdk-1.0rc2.tar.gz, https://ftp.mozilla.org/pub/mozilla.org/labs/j... |
[
"the first index and times along the second. \"\"\" #",
"altitude = observer._altaz_cache[aakey]['altitude'] return altitude def compute_constraint(self, times, observer, targets):",
"in constraints] constraint_arr = np.logical_and.reduce(applied_constraints) return np.any(constraint_arr, axis=1) def is_event_o... |
[
"= 'index' return render(request, 'backend/index.html', context) @login_required() def posts(request): context",
"tags = paginator.page(paginator.num_pages) context['tags'] = tags return render(request, 'backend/tags.html', context)",
"created.') return HttpResponseRedirect(reverse('user_panel_tags')) context['... |
[
") -> Tuple[_mp.Process, IRPCModelSession]: client_conn, server_conn = _mp.Pipe() proc =",
"as _mp import uuid import zipfile from concurrent.futures import Future",
"= uuid.uuid4().hex self._datasets[id_] = {\"mean\": mean, \"stddev\": stddev} return id_",
"res def create_dataset(self, mean, stddev): id_ = u... |
[
"new entities Result: - 'Copy->Pasted' entities won't have same AvalonID",
"ignore_me = True def launch(self, session, event): created = []",
"priority = SyncToAvalonEvent.priority - 1 ignore_me = True def launch(self,",
"= event['data']['entities'] for entity in entities: try: entity_id = entity['entityId']"... |
[
"= workflow_IngestAcceptedSubmission( settings_mock, FakeLogger(), None, None, None, None ) def",
"settings_mock, FakeLogger(), None, None, None, None ) def test_init(self): self.assertEqual(self.workflow.name,",
"workflow_IngestAcceptedSubmission( settings_mock, FakeLogger(), None, None, None, None ) def test_... |
[
"the setup magic. api = vumi_api() token_data = api.token_manager.get(token) if",
"here, but it's saner to get a whole # vumi_api",
"need to be if not user_id or request.user.id == user_id:",
"user_id or request.user.id == user_id: path, _, qs = redirect_to.partition('?')",
"== user_id: path, _, qs = redire... |
[
"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))",
"out = f(text) except TypogrifyError, e: if settings.DEBUG: raise e",
"django.utils.encoding impor... |
[
"binary data: int (4 bytes) data, = struct.unpack('<i', f.read(4)) header[\"PosInfosVerified\"]",
"data # First slice center Z coordinate data, = struct.unpack('<f',",
"are stored as a series of bytes. See the V16",
"Then follows eventually a section listing spatial # transformations which",
"in # the conte... |
[
"[.77, .78] for (m, g) in zip(models, accs): acc =",
"# # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law",
"+ .1 def test_imagenet1k_inception_bn(**kwargs): acc = mx.metric.create('acc') m = 'imagenet1k-inception-bn'",
"OF ANY # KIND, either express or implied. See the",
"'... |
[
"parent vDataFrame is modified. Attributes ---------- alias, str : vColumn",
"\"DECODE({}, '{}', 1, 0)\".format( \"{}\", str(distinct_elements[k]).replace(\"'\", \"''\") ) transformations =",
"if (nullifzero) else \"\", cmax, cmin, ), \"float\", \"float\", )",
"One-Hot Encoding. \"\"\" check_types([(\"respons... |
[
"from datatables import ColumnDT, DataTables from .. import auth from",
": {id}\" @book.route('/post/', methods=['GET', 'POST']) def post_book(): \"\"\" post new",
"= int(book[-1].id) + 1 print(f\"id is : {id}\") form =",
"be displayed. from flask import render_template, redirect, request, url_for, flash,json... |
[
"png = 'image/png' txt = 'text/plain; charset=us-ascii' json = 'application/json'",
"Enum class content_type(Enum): # https://www.iana.org/assignments/media-types/media-types.xhtml css = 'text/css' gif =",
"# https://www.iana.org/assignments/media-types/media-types.xhtml css = 'text/css' gif = 'image/gif' htm =... |