tablecloth.api — scicloj/tablecloth 1.0.0-pre-alpha1

->array clj

(->array ds colname)

(->array ds colname datatype)

Convert numerical column(s) to java array

add-or-replace-column clj

(add-or-replace-column ds column-name column)

(add-or-replace-column ds column-name column size-strategy)

Add or update (modify) column under column-name.

column can be sequence of values or generator function (which gets ds as input).

add-or-replace-columns clj

(add-or-replace-columns ds columns-map)

(add-or-replace-columns ds columns-map size-strategy)

Add or updade (modify) columns defined in columns-map (mapping: name -> column)

aggregate clj

(aggregate ds aggregator)

(aggregate ds
           aggregator
           {:keys [default-column-name-prefix ungroup?]
            :or {default-column-name-prefix "summary" ungroup? true}
            :as options})

Aggregate dataset by providing:

• aggregation function
• map with column names and functions
• sequence of aggregation functions

Aggregation functions can return:

• single value
• seq of values
• map of values with column names

aggregate-columns clj

(aggregate-columns ds columns-selector column-aggregators)

(aggregate-columns ds columns-selector column-aggregators options)

Aggregates each column separately

anti-join clj

(anti-join ds-left ds-right columns-selector)

(anti-join ds-left ds-right columns-selector options)

append clj

(append ds & datasets)

as-regular-dataset clj

bind clj

(bind ds & datasets)

by-rank clj

(by-rank ds columns-selector rank-predicate)

(by-rank ds
         columns-selector
         rank-predicate
         {:keys [desc? ties] :or {desc? true ties :dense}})

Select rows using rank on a column, ties are resolved using :dense method.

See R docs. Rank uses 0 based indexing.

Possible :ties strategies: :average, :first, :last, :random, :min, :max, :dense. :dense is the same as in data.table::frank from R

:desc? set to true (default) order descending before calculating rank

clone clj

(clone item)

(clone item datatype)

Create a new thing from the old thing and copy data into new thing.

column clj

(column dataset column-name)

Return the column or throw if it doesn't exist.

column-count clj

(column-count dataset)

column-names clj

(column-names ds)

(column-names ds columns-selector)

(column-names ds columns-selector meta-field)

columns clj

(columns ds)

(columns ds result-type)

concat clj

(concat dataset & other-datasets)

Concatenate datasets. Respects missing values. Datasets must all have the same columns. Result column datatypes will be a widening cast of the datatypes.

convert-types clj

(convert-types ds coltype-map)

(convert-types ds columns-selector new-types)

Convert type of the column to the other type.

dataset clj

(dataset)

(dataset data)

(dataset data
         {:keys [single-value-column-name]
          :or {single-value-column-name :$value}
          :as options})

Create dataset.

Dataset can be created from:

• single value
• map of values and/or sequences
• sequence of maps
• sequence of columns
• file or url

dataset->str clj

(dataset->str ds)

(dataset->str ds options)

Convert a dataset to a string. Prints a single line header and then calls dataset-data->str.

For options documentation see dataset-data->str.

dataset-name clj

(dataset-name dataset)

dataset? clj

(dataset? ds)

Is ds a dataset type?

difference clj

(difference ds-left ds-right)

(difference ds-left ds-right options)

drop clj

drop-columns clj

Drop columns by (returns dataset):

• name
• sequence of names
• map of names with new names (rename)
• function which filter names (via column metadata)

drop-missing clj

Drop rows with missing values

columns-selector selects columns to look at missing values

drop-rows clj

Drop rows using:

• row id
• seq of row ids
• seq of true/false
• fn with predicate

first clj

(first ds)

fold-by clj

(fold-by ds columns-selector)

(fold-by ds columns-selector folding-function)

full-join clj

(full-join ds-left ds-right columns-selector)

(full-join ds-left ds-right columns-selector options)

group-by clj

(group-by ds grouping-selector)

(group-by
  ds
  grouping-selector
  {:keys [select-keys result-type] :or {result-type :as-dataset} :as options})

Group dataset by:

• column name
• list of columns
• map of keys and row indexes
• function getting map of values

Options are:

• select-keys - when grouping is done by function, you can limit fields to a select-keys seq.
• result-type - return results as dataset (:as-dataset, default) or as map of datasets (:as-map) or as map of row indexes (:as-indexes) or as sequence of (sub)datasets
• other parameters which are passed to dataset fn

When dataset is returned, meta contains :grouped? set to true. Columns in dataset:

• name - group name
• group-id - id of the group (int)
• data - group as dataset

grouped? clj

(grouped? ds)

Is dataset represents grouped dataset (result of group-by)?

groups->map clj

(groups->map ds)

Convert grouped dataset to the map of groups

groups->seq clj

(groups->seq ds)

has-column? clj

(has-column? dataset column-name)

head clj

(head ds)

(head ds n)

info clj

(info ds)

(info ds result-type)

inner-join clj

(inner-join ds-left ds-right columns-selector)

(inner-join ds-left ds-right columns-selector options)

intersect clj

(intersect ds-left ds-right)

(intersect ds-left ds-right options)

join-columns clj

(join-columns ds target-column columns-selector)

(join-columns ds
              target-column
              columns-selector
              {:keys [separator missing-subst drop-columns? result-type]
               :or {separator "-" drop-columns? true result-type :string}
               :as options})

last clj

(last ds)

left-join clj

(left-join ds-left ds-right columns-selector)

(left-join ds-left ds-right columns-selector options)

map-columns clj

(map-columns ds column-name map-fn)

(map-columns ds column-name columns-selector map-fn)

order-by clj

(order-by ds columns-or-fn)

(order-by ds columns-or-fn comparators)

(order-by ds columns-or-fn comparators {:keys [select-keys]})

Order dataset by:

• column name
• columns (as sequence of names)
• key-fn
• sequence of columns / key-fn Additionally you can ask the order by:
• :asc
• :desc
• custom comparator function

pivot->longer clj

(pivot->longer ds columns-selector)

(pivot->longer
  ds
  columns-selector
  {:keys [target-columns value-column-name splitter drop-missing? datatypes]
   :or {target-columns :$column value-column-name :$value drop-missing? true}})

tidyr pivot_longer api

pivot->wider clj

(pivot->wider ds columns-selector value-columns)

(pivot->wider ds
              columns-selector
              value-columns
              {:keys [fold-fn concat-columns-with concat-value-with]
               :or {concat-columns-with "_" concat-value-with "-"}})

print-dataset clj

(print-dataset ds)

(print-dataset ds options)

process-group-data clj

(process-group-data ds f)

rand-nth clj

(rand-nth ds)

(rand-nth ds {:keys [seed]})

random clj

(random ds)

(random ds n)

(random ds n {:keys [repeat? seed] :or {repeat? true}})

rename-columns clj

(rename-columns ds columns-mapping)

(rename-columns ds columns-selector columns-map-fn)

Rename columns with provided old -> new name map

reorder-columns clj

(reorder-columns ds columns-selector & columns-selectors)

Reorder columns using column selector(s). When column names are incomplete, the missing will be attached at the end.

replace-missing clj

(replace-missing ds value)

(replace-missing ds columns-selector value)

(replace-missing ds columns-selector value strategy)

right-join clj

(right-join ds-left ds-right columns-selector)

(right-join ds-left ds-right columns-selector options)

row-count clj

(row-count dataset)

rows clj

(rows ds)

(rows ds result-type)

select clj

select-columns clj

Select columns by (returns dataset):

• name
• sequence of names
• map of names with new names (rename)
• function which filter names (via column metadata)

select-missing clj

Select rows with missing values

columns-selector selects columns to look at missing values

select-rows clj

Select rows using:

• row id
• seq of row ids
• seq of true/false
• fn with predicate

semi-join clj

(semi-join ds-left ds-right columns-selector)

(semi-join ds-left ds-right columns-selector options)

separate-column clj

(separate-column ds column target-columns)

(separate-column ds column target-columns separator)

(separate-column ds
                 column
                 target-columns
                 separator
                 {:keys [missing-subst drop-column?]
                  :or {missing-subst "" drop-column? true}})

set-dataset-name clj

(set-dataset-name dataset ds-name)

shape clj

(shape ds)

Returns shape of the dataset [rows, cols]

shuffle clj

(shuffle ds)

(shuffle ds {:keys [seed]})

tail clj

(tail ds)

(tail ds n)

ungroup clj

(ungroup ds)

(ungroup ds
         {:keys [order? add-group-as-column add-group-id-as-column separate?
                 dataset-name]
          :or {separate? true}})

Concat groups into dataset.

When add-group-as-column or add-group-id-as-column is set to true or name(s), columns with group name(s) or group id is added to the result.

Before joining the groups groups can be sorted by group name.

union clj

(union ds & datasets)

unique-by clj

(unique-by ds)

(unique-by ds columns-selector)

(unique-by ds
           columns-selector
           {:keys [strategy select-keys] :or {strategy :first} :as options})

unmark-group clj

(unmark-group ds)

Remove grouping tag

unroll clj

(unroll ds columns-selector)

(unroll ds columns-selector options)

update-columns clj

(update-columns ds columns-map)

(update-columns ds columns-selector update-functions)

write-csv! clj

(write-csv! ds output)

(write-csv! ds output options)

Write a dataset to a tsv or csv output stream. Closes output if a stream is passed in. File output format will be inferred if output is a string -

• .csv, .tsv - switches between tsv, csv. Tsv is the default.
• *.gz - write to a gzipped stream. At this time writing to json is not supported. options - :separator - in case output isn't a string, you can use either , or \tab to switch between csv or tsv output respectively.