Liking cljdoc? Tell your friends :D
Clojure only.

scicloj.ml.metamorph

This namespace contains functions, which operate on a metamorph context. They all return the context as well.

So all functions in this namespace are metamorph compliant and can be placed in a metamorph pipeline.

Most functions here are only manipulating the dataset, which is in the ctx map under the key :metamorph/data. And they behave the same in pipeline mode :fit and :transform.

A few functions manipulate other keys inside the ctx map, and/or behave different in :fit and :transform.

This is documented per function in this form:

metamorph.
Behaviour in mode :fit.
Behaviour in mode :transform.
Reads keys from ctx.
Writes keys to ctx.

The namespaces scicloj.ml.metamorph and scicloj.ml.dataset contain functions with the same name. But they operate on either a context map (ns metamorph) or on a dataset (ns dataset)

The functions in this namesspaces are re-exported from :

  • tablecloth.pipeline
  • tech.v3.libs.smile.metamorph
  • scicloj.metamorph.ml
  • tech.v3.dataset.metamorph
This namespace contains functions, which operate on a metamorph context.
They all return the context as well.

So all functions in this namespace are metamorph compliant and can
be placed in a metamorph pipeline.

Most functions here are only manipulating the dataset, which is in the ctx map
under the key :metamorph/data.
And they behave the same in pipeline mode :fit and :transform.


A few functions manipulate other keys inside the ctx map, and/or behave
different in :fit and :transform.

This is documented per function in this form:

metamorph                            | .
-------------------------------------|------------------------------
Behaviour in mode :fit               | .
Behaviour in mode :transform         | .
Reads keys from ctx                  | .
Writes keys to ctx                   | .



The namespaces scicloj.ml.metamorph and scicloj.ml.dataset contain
functions with the same name. But they operate on either a context
map (ns metamorph) or on a dataset (ns dataset)

The functions in this namesspaces are re-exported from :

* tablecloth.pipeline
* tech.v3.libs.smile.metamorph
* scicloj.metamorph.ml
* tech.v3.dataset.metamorph

raw docstring

->arrayclj

(->array colname)
(->array colname datatype)

Convert numerical column(s) to java array

Convert numerical column(s) to java array
raw docstring

add-columnclj

(add-column column-name column)
(add-column 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 update (modify) column under `column-name`.

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

add-columnsclj

(add-columns columns-map)
(add-columns columns-map size-strategy)

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

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

add-or-replace-columnclj

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

add-or-replace-columnsclj

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

add-or-update-columnclj

(add-or-update-column column)
(add-or-update-column colname column)

aggregateclj

(aggregate aggregator)
(aggregate aggregator 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 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
raw docstring

aggregate-columnsclj

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

Aggregates each column separately

Aggregates each column separately
raw docstring

anti-joinclj

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

appendclj

(append & datasets)

append-columnsclj

(append-columns column-seq)

as-regular-datasetclj

(as-regular-dataset)

Remove grouping tag

Remove grouping tag
raw docstring

asof-joinclj

(asof-join ds-right colname)
(asof-join ds-right colname options)

assoc-dsclj

(assoc-ds cname cdata & args)

assoc-metadataclj

(assoc-metadata filter-fn-or-ds k v & args)

bindclj

(bind & datasets)

bow->something-sparseclj

(bow->something-sparse bow-col indices-col bow->sparse-fn options)

Converts a bag-of-word column bow-col to a sparse data column indices-col. The exact transformation to the sparse representtaion is given by bow->sparse-fn

metamorph.
Behaviour in mode :fitnormal
Behaviour in mode :transformnormal
Reads keys from ctxnone
Writes keys to ctx:scicloj.ml.smile.metamorph/bow->sparse-vocabulary
Converts a bag-of-word column `bow-col` to a sparse data column `indices-col`.
 The exact transformation to the sparse representtaion is given by `bow->sparse-fn`

metamorph                            |.
-------------------------------------|---------
Behaviour in mode :fit               |normal
Behaviour in mode :transform         |normal
Reads keys from ctx                  |none
Writes keys to ctx                   |:scicloj.ml.smile.metamorph/bow->sparse-vocabulary

raw docstring

bow->sparse-arrayclj

(bow->sparse-array bow-col indices-col)
(bow->sparse-array bow-col indices-col options)

Converts a bag-of-word column bow-col to sparse indices column indices-col, as needed by the Maxent model. vocab size is the size of vocabluary used, sorted by token frequency

metamorph.
Behaviour in mode :fitnormal
Behaviour in mode :transformnormal
Reads keys from ctxnone
Writes keys to ctx:scicloj.ml.smile.metamorph/count-vectorize-vocabulary
Converts a bag-of-word column `bow-col` to sparse indices column `indices-col`,
 as needed by the Maxent model.
 `vocab size` is the size of vocabluary used, sorted by token frequency

metamorph                            |.
-------------------------------------|---------
Behaviour in mode :fit               |normal
Behaviour in mode :transform         |normal
Reads keys from ctx                  |none
Writes keys to ctx                   |:scicloj.ml.smile.metamorph/count-vectorize-vocabulary

raw docstring

bow->SparseArrayclj

(bow->SparseArray bow-col indices-col)
(bow->SparseArray bow-col indices-col options)

Converts a bag-of-word column bow-col to sparse indices column indices-col, as needed by the discrete naive bayes model. vocab size is the size of vocabluary used, sorted by token frequency

metamorph.
Behaviour in mode :fitnormal
Behaviour in mode :transformnormal
Reads keys from ctxnone
Writes keys to ctx:scicloj.ml.smile.metamorph/count-vectorize-vocabulary
Converts a bag-of-word column `bow-col` to sparse indices column `indices-col`,
 as needed by the discrete naive bayes model. `vocab size` is the size of vocabluary used, sorted by token frequency

metamorph                            |.
-------------------------------------|---------
Behaviour in mode :fit               |normal
Behaviour in mode :transform         |normal
Reads keys from ctx                  |none
Writes keys to ctx                   |:scicloj.ml.smile.metamorph/count-vectorize-vocabulary

raw docstring

bow->tfidfclj

(bow->tfidf bow-column tfidf-column)

Calculates the tfidf score from bag-of-words (as token frequency maps) in column bow-column and stores them in a new column tfid-column as maps of token->tfidf-score.

metamorph.
Behaviour in mode :fitnormal
Behaviour in mode :transformnormal
Reads keys from ctxnone
Writes keys to ctxnone
Calculates the tfidf score from bag-of-words (as token frequency maps)
 in column `bow-column` and stores them in a new column `tfid-column` as maps of token->tfidf-score.


metamorph                            |.
-------------------------------------|---------
Behaviour in mode :fit               |normal
Behaviour in mode :transform         |normal
Reads keys from ctx                  |none
Writes keys to ctx                   |none
raw docstring

briefclj

(brief)
(brief options)

by-rankclj

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

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

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

See [R docs](https://www.rdocumentation.org/packages/base/versions/3.6.1/topics/rank).
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
raw docstring

categorical->numberclj

(categorical->number filter-fn-or-ds)
(categorical->number filter-fn-or-ds table-args)
(categorical->number filter-fn-or-ds table-args result-datatype)

categorical->one-hotclj

(categorical->one-hot filter-fn-or-ds)
(categorical->one-hot filter-fn-or-ds table-args)
(categorical->one-hot filter-fn-or-ds table-args result-datatype)

cloneclj

(clone)

Clone an object. Can clone anything convertible to a reader.

Clone an object.  Can clone anything convertible to a reader.
raw docstring

columnclj

(column colname)

column->datasetclj

(column->dataset colname transform-fn)
(column->dataset colname transform-fn options)

column-castclj

(column-cast colname datatype)

column-countclj

(column-count)

column-labeled-mapseqclj

(column-labeled-mapseq value-colname-seq)

column-mapclj

(column-map result-colname map-fn)
(column-map result-colname map-fn filter-fn-or-ds)
(column-map result-colname map-fn res-dtype filter-fn-or-ds)

column-namesclj

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

column-values->categoricalclj

(column-values->categorical src-column)

columnsclj

(columns)
(columns result-type)

columns-with-missing-seqclj

(columns-with-missing-seq)

columnwise-concatclj

(columnwise-concat colnames)
(columnwise-concat colnames options)

concatclj

(concat & datasets)

concat-copyingclj

(concat-copying & datasets)

concat-inplaceclj

(concat-inplace & datasets)

convert-typesclj

(convert-types coltype-map-or-columns-selector)
(convert-types columns-selector new-types)

Convert type of the column to the other type.

Convert type of the column to the other type.
raw docstring

count-vectorizeclj

(count-vectorize text-col bow-col)
(count-vectorize text-col bow-col options)

Transforms the text column text-col into a map of token frequencies in column bow-col

metamorph.
Behaviour in mode :fitnormal
Behaviour in mode :transformnormal
Reads keys from ctxnone
Writes keys to ctxnone
Transforms the text column `text-col` into a map of token frequencies in column
`bow-col`

metamorph                            |.
-------------------------------------|---------
Behaviour in mode :fit               |normal
Behaviour in mode :transform         |normal
Reads keys from ctx                  |none
Writes keys to ctx                   |none
raw docstring

data->datasetclj

(data->dataset)

dataset->categorical-xformsclj

(dataset->categorical-xforms)

dataset->dataclj

(dataset->data)

dataset->strclj

(dataset->str)
(dataset->str 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.

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

For options documentation see dataset-data->str.
raw docstring

dataset-nameclj

(dataset-name)

dataset?clj

(dataset?)

Is ds a dataset type?

Is `ds` a `dataset` type?
raw docstring

descriptive-statsclj

(descriptive-stats)
(descriptive-stats options)

differenceclj

(difference ds-right)
(difference ds-right options)

dropclj

(drop columns-selector rows-selector)

Drop columns and rows.

Drop columns and rows.
raw docstring

drop-columnsclj

(drop-columns)
(drop-columns columns-selector)
(drop-columns columns-selector meta-field)

Drop columns by (returns dataset):

  • name
  • sequence of names
  • map of names with new names (rename)
  • function which filter names (via column metadata)
Drop columns by (returns dataset):

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

drop-missingclj

(drop-missing)
(drop-missing columns-selector)

Drop rows with missing values

columns-selector selects columns to look at missing values

Drop rows with missing values

`columns-selector` selects columns to look at missing values
raw docstring

drop-rowsclj

(drop-rows)
(drop-rows rows-selector)
(drop-rows rows-selector options)

Drop rows using:

  • row id
  • seq of row ids
  • seq of true/false
  • fn with predicate
Drop rows using:

- row id
- seq of row ids
- seq of true/false
- fn with predicate
raw docstring

empty-ds?clj

(empty-ds?)

ensure-array-backedclj

(ensure-array-backed)
(ensure-array-backed options)

feature-ecountclj

(feature-ecount)

fill-range-replaceclj

(fill-range-replace colname max-span)
(fill-range-replace colname max-span missing-strategy)
(fill-range-replace colname max-span missing-strategy missing-value)

filterclj

(filter predicate)

filter-columnclj

(filter-column colname predicate)

filter-datasetclj

(filter-dataset filter-fn-or-ds)

firstclj

(first)

fold-byclj

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

full-joinclj

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

group-byclj

(group-by grouping-selector)
(group-by grouping-selector 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
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
raw docstring

group-by->indexesclj

(group-by->indexes key-fn)

group-by-columnclj

(group-by-column colname)

group-by-column->indexesclj

(group-by-column->indexes colname)

grouped?clj

(grouped?)

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

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

groups->mapclj

(groups->map)

Convert grouped dataset to the map of groups

Convert grouped dataset to the map of groups
raw docstring

groups->seqclj

(groups->seq)

has-column?clj

(has-column? column-name)

(head)
(head n)

inference-column?clj

(inference-column?)

inference-target-column-namesclj

(inference-target-column-names)

inference-target-dsclj

(inference-target-ds)

inference-target-label-inverse-mapclj

(inference-target-label-inverse-map & [label-columns])

inference-target-label-mapclj

(inference-target-label-map & [label-columns])

infoclj

(info)
(info result-type)

inner-joinclj

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

intersectclj

(intersect ds-right)
(intersect ds-right options)

join-columnsclj

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

labelsclj

(labels)

lastclj

(last)

left-joinclj

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

map-columnsclj

(map-columns column-name map-fn)
(map-columns column-name columns-selector map-fn)
(map-columns column-name new-type columns-selector map-fn)

mapseq-readerclj

(mapseq-reader)

mark-as-groupclj

(mark-as-group)

Add grouping tag

Add grouping tag
raw docstring

missingclj

(missing)

modelclj

(model options)

Executes a machine learning model in train/predict (depending on :mode) from the metamorph.ml model registry.

The model is passed between both invocation via the shared context ctx in a key (a step indentifier) which is passed in key :metamorph/id and guarantied to be unique for each pipeline step.

The function writes and reads into this common context key.

Options:

  • :model-type - Keyword for the model to use

Further options get passed to train functions and are model specific.

See here for an overview for the models build into scicloj.ml:

https://scicloj.github.io/scicloj.ml/userguide-models.html

Other libraries might contribute other models, which are documented as part of the library.

metamorph.
Behaviour in mode :fitCalls scicloj.metamorph.ml/train using data in :metamorph/data and optionsand stores trained model in ctx under key in :metamorph/id
Behaviour in mode :transformReads trained model from ctx and calls scicloj.metamorph.ml/predict with the model in $id and data in :metamorph/data
Reads keys from ctxIn mode :transform : Reads trained model to use for prediction from key in :metamorph/id.
Writes keys to ctxIn mode :fit : Stores trained model in key $id and writes feature-ds and target-ds before prediction into ctx at :scicloj.metamorph.ml/feature-ds /:scicloj.metamorph.ml/target-ds

See as well:

  • scicloj.metamorph.ml/train
  • scicloj.metamorph.ml/predict
Executes a machine learning model in train/predict (depending on :mode)
from the `metamorph.ml` model registry.

The model is passed between both invocation via the shared context ctx in a
key (a step indentifier) which is passed in key `:metamorph/id` and guarantied to be unique for each
pipeline step.

The function writes and reads into this common context key.

Options:
- `:model-type` - Keyword for the model to use

Further options get passed to `train` functions and are model specific.

See here for an overview for the models build into scicloj.ml:

https://scicloj.github.io/scicloj.ml/userguide-models.html

Other libraries might contribute other models,
which are documented as part of the library.


metamorph                            | .
-------------------------------------|----------------------------------------------------------------------------
Behaviour in mode :fit               | Calls `scicloj.metamorph.ml/train` using data in `:metamorph/data` and `options`and stores trained model in ctx under key in `:metamorph/id`
Behaviour in mode :transform         | Reads trained model from ctx and calls `scicloj.metamorph.ml/predict` with the model in $id and data in `:metamorph/data`
Reads keys from ctx                  | In mode `:transform` : Reads trained model to use for prediction from key in `:metamorph/id`.
Writes keys to ctx                   | In mode `:fit` : Stores trained model in key $id and writes feature-ds and target-ds before prediction into ctx at `:scicloj.metamorph.ml/feature-ds` /`:scicloj.metamorph.ml/target-ds`




See as well:

* `scicloj.metamorph.ml/train`
* `scicloj.metamorph.ml/predict`

raw docstring

model-typeclj

(model-type & [column-name-seq])

new-columnclj

(new-column data)
(new-column data metadata)
(new-column data metadata missing)

new-datasetclj

(new-dataset)
(new-dataset column-seq)
(new-dataset ds-metadata column-seq)

num-inference-classesclj

(num-inference-classes)

order-byclj

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

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
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
raw docstring

order-column-namesclj

(order-column-names colname-seq)

pivot->longerclj

(pivot->longer)
(pivot->longer columns-selector)
(pivot->longer columns-selector options)

tidyr pivot_longer api

`tidyr` pivot_longer api
raw docstring

pivot->widerclj

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

(print-dataset)
(print-dataset options)

probability-distributions->label-columnclj

(probability-distributions->label-column dst-colname)

process-group-dataclj

(process-group-data f)
(process-group-data f parallel?)

rand-nthclj

(rand-nth)
(rand-nth options)

randomclj

(random)
(random n)
(random n options)

read-nippyclj

(read-nippy)

remove-columnclj

(remove-column col-name)

remove-columnsclj

(remove-columns colname-seq-or-fn)

remove-rowsclj

(remove-rows row-indexes)

rename-columnsclj

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

Rename columns with provided old -> new name map

Rename columns with provided old -> new name map
raw docstring

reorder-columnsclj

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

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

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

replace-missingclj

(replace-missing)
(replace-missing strategy)
(replace-missing columns-selector strategy)
(replace-missing columns-selector strategy value)

replace-missing-valueclj

(replace-missing-value scalar-value)
(replace-missing-value filter-fn-or-ds scalar-value)

right-joinclj

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

row-countclj

(row-count)

rowsclj

(rows)
(rows result-type)

sampleclj

(sample)
(sample n)
(sample n options)

selectclj

(select columns-selector rows-selector)

Select columns and rows.

Select columns and rows.
raw docstring

select-by-indexclj

(select-by-index col-index row-index)

select-columnsclj

(select-columns)
(select-columns columns-selector)
(select-columns columns-selector meta-field)

Select columns by (returns dataset):

  • name
  • sequence of names
  • map of names with new names (rename)
  • function which filter names (via column metadata)
Select columns by (returns dataset):

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

select-columns-by-indexclj

(select-columns-by-index col-index)

select-missingclj

(select-missing)
(select-missing columns-selector)

Select rows with missing values

columns-selector selects columns to look at missing values

Select rows with missing values

`columns-selector` selects columns to look at missing values
raw docstring

select-rowsclj

(select-rows)
(select-rows rows-selector)
(select-rows rows-selector options)

Select rows using:

  • row id
  • seq of row ids
  • seq of true/false
  • fn with predicate
Select rows using:

- row id
- seq of row ids
- seq of true/false
- fn with predicate
raw docstring

select-rows-by-indexclj

(select-rows-by-index row-index)

semi-joinclj

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

separate-columnclj

(separate-column column separator)
(separate-column column target-columns separator)
(separate-column column target-columns separator options)

set-dataset-nameclj

(set-dataset-name ds-name)

set-inference-targetclj

(set-inference-target target-name-or-target-name-seq)

shapeclj

(shape)

Returns shape of the dataset [rows, cols]

Returns shape of the dataset [rows, cols]
raw docstring

shuffleclj

(shuffle)
(shuffle options)

sort-byclj

(sort-by key-fn)
(sort-by key-fn compare-fn)

sort-by-columnclj

(sort-by-column colname)
(sort-by-column colname compare-fn)

tailclj

(tail)
(tail n)

take-nthclj

(take-nth n-val)

ungroupclj

(ungroup)
(ungroup options)

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.

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.
raw docstring

unionclj

(union & datasets)

unique-byclj

(unique-by)
(unique-by columns-selector)
(unique-by columns-selector options)

unique-by-columnclj

(unique-by-column colname)
(unique-by-column options colname)

unmark-groupclj

(unmark-group)

Remove grouping tag

Remove grouping tag
raw docstring

unordered-selectclj

(unordered-select colname-seq index-seq)

unrollclj

(unroll columns-selector)
(unroll columns-selector options)

unroll-columnclj

(unroll-column column-name)
(unroll-column column-name options)

updateclj

(update filter-fn-or-ds update-fn & args)

update-columnclj

(update-column col-name update-fn)

update-columnsclj

(update-columns columns-map)
(update-columns columns-selector update-functions)

update-columnwiseclj

(update-columnwise filter-fn-or-ds cwise-update-fn & args)

update-elemwiseclj

(update-elemwise map-fn)
(update-elemwise filter-fn-or-ds map-fn)

value-readerclj

(value-reader)

write!clj

(write! output-path)
(write! output-path options)

Write a dataset out to a file. Supported forms are:

(ds/write! test-ds "test.csv")
(ds/write! test-ds "test.tsv")
(ds/write! test-ds "test.tsv.gz")
(ds/write! test-ds "test.nippy")
(ds/write! test-ds out-stream)

Options:

  • :max-chars-per-column - csv,tsv specific, defaults to 65536 - values longer than this will cause an exception during serialization.
  • :max-num-columns - csv,tsv specific, defaults to 8192 - If the dataset has more than this number of columns an exception will be thrown during serialization.
  • :quoted-columns - csv specific - sequence of columns names that you would like to always have quoted.
  • :file-type - Manually specify the file type. This is usually inferred from the filename but if you pass in an output stream then you will need to specify the file type.
  • :headers? - if csv headers are written, defaults to true.
Write a dataset out to a file.  Supported forms are:

```clojure
(ds/write! test-ds "test.csv")
(ds/write! test-ds "test.tsv")
(ds/write! test-ds "test.tsv.gz")
(ds/write! test-ds "test.nippy")
(ds/write! test-ds out-stream)
```

Options:

  * `:max-chars-per-column` - csv,tsv specific, defaults to 65536 - values longer than this will
     cause an exception during serialization.
  * `:max-num-columns` - csv,tsv specific, defaults to 8192 - If the dataset has more than this number of
     columns an exception will be thrown during serialization.
  * `:quoted-columns` - csv specific - sequence of columns names that you would like to always have quoted.
  * `:file-type` - Manually specify the file type.  This is usually inferred from the filename but if you
     pass in an output stream then you will need to specify the file type.
  * `:headers?` - if csv headers are written, defaults to true.
raw docstring

write-nippy!clj

(write-nippy! filename)

cljdoc is a website building & hosting documentation for Clojure/Script libraries

× close