text:
# iOS TDD Workshop: Build your App Using Tests!

Skeleton of iOS TDD Workshop with Quick and Nimble

Pre-Requisites:
------
You will need an App Store account to download Xcode, use [this link](https://itunes.apple.com/us/app/xcode/id497799835?mt=12) to download it on your Mac computer.

What we will build 👩💻:
------
**FizzBuzz Game**: A fun new take on the classic FizzBuzz game. Count as high as you can before the time runs out.

The aim of the game is to count up as high as you can before time runs out, starting at 1.
- If the next number is a multiple of 3, tap the “Fizz” button.
- If the next number is a multiple of 5, tap the “Buzz” button.
- If the next number is a multiple of 3 AND 5, tap the “FizzBuzz” button.

![FizzBuzz game](https://cdn-images-1.medium.com/max/1600/1*_LDFqES_tjwjzyZw97k4Ng.png)

The app is available to download free from the [App Store](https://itunes.apple.com/us/app/bizzfuzz/id1065354200?mt=8) made by [Yvette Cook](https://github.com/yvettecook) and we will be building a very similar game. You can and should try it out before the Workshop.

What you will Learn 🎉:
------
- Build/Run an app with Xcode
- Build/Run Unit and UI Tests with Quick and Nimble with XCode
- Create Custom Views and View Controllers
- Create Custom Data Models through Structures
- How to pass information through Controllers
- Use Timers and Notifications
- Test your sources with Quick and Nimble
- Use Fastlane to automate the Tests process

Learn More 🤓:
------
To prepare for the workshop or to keep learning swift after it we recommend this guides

- [What is TDD?](https://medium.com/mobile-quality/test-driven-development-d16fd216d45c)
- [TDD using Quick & Nimble](https://medium.com/inloopx/tdd-using-quick-nimble-244b14b09e3d)
- [iOS Architecture Patterns](https://medium.com/ios-os-x-development/ios-architecture-patterns-ecba4c38de52)
- [8 Observations On Test Driven Development](https://medium.com/@solidi/8-observations-on-test-driven-development-a9b5144f868)

repository: raafaelima/iOSTDDWorkshopSkeleton

repo_name: raafaelima/iOSTDDWorkshopSkeleton


text:
---
layout: post
title: "RSS? You should probably try TTR"
date: 2015-01-24
categories: []
---
As a long-time consumer of RSS feeds, I was shocked along with many others at
the fairly sudden termination of Google Reader. Though there wasn't anything
extraordinarily special about GR for me, it did offer a clean, simple way to browse
feeds and have the status sync across devices. Like everyone else, I set about
finding a replacement, and was pretty sure I'd find one in short order that met my
expectations.

Nope.

Many were major departures from the clean, boring, email-like lists that I liked
and was looking for. A lot of the ones trying to mimic the old layout couldn't deliver
on performance, or a mobile app, or were a bit spendy for my liking, etc. So for over a year I floated around, trying this and that, never feeling
at all settled. Then I saw reference in a Hacker News comment thread about
[Tiny Tiny RSS](http://tt-rss.org/) (TTR) and decided to give it a try.  Great decision,
and I've not once been left wanting for a better RSS reader.

The main hurdle for most people is that you will have to host the thing yourself.
If you can stomach that, you'll be extremely happy. Hell, your nerd circle can
easily mooch off of your server if they want, since it's easy to create individual
accounts. What you'll get in return for your efforts is a very good web and App
experience (at least on Android... don't know about iOS), delivering what you'd
expect from a basic RSS aggregator, on your terms and server. All nice and
GPL'd... Your RSS Reader won't be going out of business until you quit paying your server bills.

As for maintenance? Basically zero after you get it set up. So don't worry about
that. It is well worth the effort to try out if you're dissatisfied with your RSS situation.

</rss>

license: MIT

branch_name: refs/heads/main

extension: md

gha_language: SCSS

gha_license_id: MIT

license_type: permissive


text:
<!-- BEGIN_TF_DOCS -->
## Requirements

No requirements.

## Providers

| Name | Version |
|------|---------|
| aws | n/a |

## Modules

No modules.

## Resources

| Name | Type |
|------|------|
| [aws_eip.nat](https://registry.terraform.io/providers/hashicorp/aws/latest/docs/resources/eip) | resource |
| [aws_instance.nat](https://registry.terraform.io/providers/hashicorp/aws/latest/docs/resources/instance) | resource |
| [aws_internet_gateway.main](https://registry.terraform.io/providers/hashicorp/aws/latest/docs/resources/internet_gateway) | resource |
| [aws_route_table.route_table_public](https://registry.terraform.io/providers/hashicorp/aws/latest/docs/resources/route_table) | resource |
| [aws_route_table_association.route_table_public](https://registry.terraform.io/providers/hashicorp/aws/latest/docs/resources/route_table_association) | resource |
| [aws_security_group.nat](https://registry.terraform.io/providers/hashicorp/aws/latest/docs/resources/security_group) | resource |

## Inputs

| Name | Description | Type | Default | Required |
|------|-------------|------|---------|:--------:|
| ami\_nat | Nat instance provide by AWS depends on the region | `any` | n/a | yes |
| aws\_vpc\_id | n/a | `any` | n/a | yes |
| key\_name | Key to access using SSH | `any` | n/a | yes |
| nat\_instance\_type | Instance type for the Nat instance | `string` | `"m1.small"` | no |
| private\_subnet\_cidrs | List of cidrs for private subnets | `list(any)` | n/a | yes |
| private\_subnets | List of private subnets | `list(any)` | n/a | yes |
| public\_subnets | List of public subnets | `list(any)` | n/a | yes |
| region | Region to deploy nat instance | `string` | `"us-east-1"` | no |
| vpc\_cidr | Cidr of the VPC | `any` | n/a | yes |

## Outputs

No outputs.
<!-- END_TF_DOCS -->

repository: AxelMonroyX/terraform-structure

branch_name: refs/heads/master

repo_name: AxelMonroyX/terraform-structure


text:
---
title: Class LoginResult
description: An object containing information about the last login attempt
category: class
navLabel: LoginResult
body_class: dark
---

The result of a login, indicating if it was successful and providing clientData

## Methods

### boolean loggedIn()

Whether or not the login completed successfully

### Object getData()

Return the data associated with login. If login was successful, this would be the user associated  clientData. Otherwise data explaining the reason why it wasn't.

### Object getErrorEvent()

The error message the server sent to explain why the client couldn't log in.

gha_language: TypeScript


text:
# social-media-textify

## Clappify

### Usage
> python clappify.py -t "Tweets with claps between the words are annoying"

outputs:

> TWEETS 👏 WITH 👏 CLAPS 👏 BETWEEN 👏 THE 👏 WORDS 👏 ARE 👏 ANNOYING

Optional arguments for the command include `-s` which is a boolean (true by default) to shout/capitalize all the letters and `-e` which lets you replace the clap emoji with any other unicode emoji.

## Spongebob

### Usage
> python spongebob.py -t "Don't use that weird spongebob mocking meme"

outputs:

> DoN'T UsE ThAt wEiRd sPoNgEbOb mOcKiNg mEmE

## Emojify (WIP)

Should be similar to [Emojifier bot on Reddit](https://www.reddit.com/user/EmojifierBot) when complete.

### Usage
> python emojify.py -t "What is this new trend with the emojis in between the text?"

outputs:

> What is this new 👌 trend 📈💵🔝 with the emojis 😀 in between 😉 the text 📱?

repository: shoumikchow/social-media-textify

repo_name: shoumikchow/social-media-textify


text:
# How It Works

Sync uses your Core Data model to infer how it will do the mapping and diffing. How the sync proccess works could be split in three parts:

- Diffing
- Relationship mapping
- Attribute mapping

### Diffing

The diffing part is the first thing is done in Sync, it separates inserted, updated and deleted items in three collections. This process is done by the [DataFilter](https://github.com/3lvis/Sync/blob/master/Source/DataFilter/DataFilter.swift). To be able to diff our entries Sync requires a primary key and a collection of remote items for comparison. If there's a local entry with the same primary key as one from the remote collection this item will go to the updated collection, if there's a remote primary key that is not found in the database then the item will go to the inserted collection, finally, if there's an item in the database that is not found in the remote collection, then this item will go to the deleted collection. At the end of this process inserted and updated items will go back to Sync where the mapping will be done, and the items in the deleted collection will be removed from the database.

A lot of times the remote collection doesn't represent all the entries in the database for a specific entity, for example, you might have in your remote collection all the articles posted in the last day, meanwhile in your database you have all the entries posted ever. To ensure that the diffing only happens with the entries in the database that were posted in the last day Sync uses a predicate, this predicate will filter out the entries in the database that will be used for comparison.

### Relationship mapping

After going through the diffing process Sync will iterate through each entry if it's an insertion it will make a new entry in the database and fill the contents of this entry with the JSON ignoring relationships. If it's an updated entry then it will just fill the attributes.

This is the method call that we would be using for the following examples:

```swift
Sync.changes(json, inEntityNamed: "Users", dataStack: dataStack) { error in
    // Completed...
}
```

#### One-to-one

One-to-one relationships have have the following structure:

```json
[
  {
    "id": 1,
    "name": "John Appleseed",
    "company": {
      "id": 12,
      "name": "Apple"
    }
  }
]
```

Here Sync will check that in your Core Data model for the User entity there's a `to-one` relationship with the Company entity. Then it will verify that there also exists a dictionary named "company" in the JSON. After doing this  then Sync will confirm that this is indeed a `to-one` relationship mapping. After, Sync will look for an existing entry in the Company table for the primary key `12`, if there's one, it will use that to link it to the user, otherwise it will make a new Company entry and link that instead, finally it will fill all the attributes of the company with the contents of the company JSON.

#### One-to-many

```json
[
  {
    "id": 1,
    "name": "John Appleseed",
    "notes": [
      {
        "id": 12,
        "text": "List of things to remember"
      }
    ]
  }
]
```

#### Many-to-many

```json
[
  {
    "id": 1,
    "name": "John Appleseed",
    "projects": [
      {
        "id": 12,
        "name": "To-do list"
      }
    ]
  }
]
```

gha_language: Swift

gha_license_id: NOASSERTION


text:
# History
## Released Versions
### Version 0.4.1
#### Patch: Added string modify module
 * Added new string methods for updating a string
   - String#camel
   - String#snake
   - String#space

### Version 0.4.0
#### Minor: Moved all existing utilise extentions to augment
 * Updated file structure still backwards compatible

### Version 0.3.0
#### Minor: Updated to_bool regex
 * Updated to_bool regular expressions

### Version 0.2.0
#### Minor: renamed from to_b to utilise as i will include other helpful tools
 * Added new to bool fuctionality for arrays and hashes
 * Added is bool matcher for Object class
 * Added unique time string to Time class

### Version 0.1.0
#### Minor: renamed from to_b to utilise as i will include other helpful tools
 * Renamed files
 * Changed to_b to to_bool

### Version 0.0.2
#### Patch: Symbol
##### Added
 * Symbol

##### Changed
 * All get converted to string first

### Version 0.0.1
#### Patch: Inital Code. Fixnum, String
##### Added
 * Fixnum
 * String

repository: Rui-Pedro-Nunes/utilise

repo_name: Rui-Pedro-Nunes/utilise


text:
Provide a remediation file as part of your deployment or service onboarding enabling automatically executing remediation workflows

```console
keptn add-resource --project=sockshop
--service=carts --stage=production
--resource=remediation.yaml
--resourceUri=remediation.yaml
```


text:
# pullrequest-nature
Software repository dedicated to datasets storage used in the thesis:

ON THE NATURE OF PULL REQUESTS: A STUDY ABOUT THIS COLLABORATION PARADIGM OVER OPEN-SOURCE PROJECTS USING ASSOCIATION RULES

Thesis presented to the Computing Graduate Program of the Fluminense Federal University, in partial fulfillment of the requirements for the degree of Doctor of Science. Area:Systems and Information Engineering.

Author: Daricélio Moreira Soares, UFAC (Federal University of Acre - Brazil)

Advisors: Leonardo Murta and Alexandre Plastino, UFF (Fluminense Federal University - Brazil)

repository: RAVEENSR/pullrequest-nature

repo_name: RAVEENSR/pullrequest-nature


text:
---
sidebarDepth: 0
---

# Dictionary

It loads the message associated to rules. It also can have messages for nonexistent rules (e.g. rules that run server-side-only but need an informative message).

This module provides a function to configure it once for the entire app in the main file.

## How it works

1. If the user has setted the `clientHandler` prop through the `setConfig` function, it invokes it.
2. If the client code doesn't have that rule, it fallbacks to the default dictionary folder.
3. If the rule still doesn't exists, it fallbacks to the `_unknownRule`. Which:
   1. First tries to get it through `clientHandler` prop.
   2. Or it fallbacks to the `_unknownRule` from the library.
4. It caches the message function.

## Exports

| Name          |   Type   | Used by end user |
| ------------- | :------: | :--------------: |
| `setConfig`   | Function |       Yes        |
| `getWarning`  | Function |        No        |
| `getMessage`  | Function |        No        |
| `loadMessage` | Function |        No        |

### setConfig

- Firm:

```ts
setConfig(config: {
  lang?: string = 'en',
  handler: (lang: string, name: string) => Promise<Module>,
}): void
```

The `handler` prop must import the dictionary file for the specific `rule` in the specific `lang`. Each of the imported files must export by default a function with the following firm:

```ts
ruleName(value, ...args): String
```

#### Example

```js
const len = (value, min, max) =>
  `The value has length "${
    String(value).length
  }" but needs to be between [${min}, ${max}]`;

export default len;
```

### getWarning

- Firm:

```ts
getWarning(
  rule: { name: string, args: Array<string> },
  value: string,
): string
```

Used by every packages. It receives an unknown rule's name and args, and returns an informative message.

### getMessage

- Firm:

```ts
getMessage(
  rule: { name: string, args: Array<string> },
  value: string,
): string
```

Used by every packages. It receives a known rule's name and args, and returns an informative message.

### loadMessage

- Firm:

```ts
loadMessage(name: string): Promise<void>
```

Used by every packages. It receives the name of the rule's message to be loaded. It loads it and caches it.

gha_language: JavaScript


text:
# Cis1 core native

> Continuous integration system core written in C++

[![License](http://img.shields.io/:license-mit-blue.svg?style=flat-square)](http://badges.mit-license.org)

This repository contains a core of continuous integration system cis1 written in C++.
This component follows the rules described in the [cis1-docs](https://github.com/tomsksoft-llc/cis1-docs/ "cis1 documentation") repository.
It's compatible with OS Linux; the support for OS Windows is not guaranteed, but we are working to add it.

## Description

Full system description, terms and entity definitions can be found on [this](https://github.com/tomsksoft-llc/cis1-docs/blob/master/overview.md "cis1 overview") document page.

## Usage

Set `cis_base_dir` environment variable to the cis1 installation directory path.

Create job. (see [cis1-docs](https://github.com/tomsksoft-llc/cis1-docs/ "cis1 documentation"))

Run the job with the following command

```console
$ ${cis_base_dir}/core/$startjob internal/core_test
```

After the command is successfully executed, the exitcode of the job and some other parameters will be displayed in the console.

## Usage with webui

Install [webui](https://github.com/tomsksoft-llc/cis1-webui-native-srv-cpp).
After successful installation, you can manage the cis core via web interface.

## Compiling

### Linux

Build requirements:
> Conan, gcc 8.3, CMake 3.9+

Add the `tomsksoft` and `bincrafters` requirements to conan

```console
$ conan remote add bincrafters https://api.bintray.com/conan/bincrafters/public-conan
$ conan remote add tomsksoft https://api.bintray.com/conan/tomsksoft/cis1
```

Switch to the build directory and install build dependencies

```console
$ conan install ${PATH_TO_SRC} --profile -s build_type=Release --build=missing
```

Generate build scripts with CMake

```console
$ cmake ${PATH_TO_SRC} -DCMAKE_BUILD_TYPE=Release
```

You can set the BUILD_DOC and BUILD_TESTING CMake variables.
The default values are:

```
BUILD_DOC     ON
BUILD_TESTING OFF
```

Run build

```console
$ cmake --build .
```

When the build is completed, the executables will appear in:

```console
${PATH_TO_BUILD_DIR}/bin
```

## Installation

Run `deploy/deploy.py`

```console
$ ./deploy.py --execs_dir ${PATH_TO_BUILT_EXECUTABLES} --deploy_dir ${PATH_WHERE_CIS_WILL_BE_DEPLOYED}
```


text:
# Denver DevOps Meetup September 12, 2018

## Used Modules
- [`terraform-google-project-factory`](https://github.com/terraform-google-modules/terraform-google-project-factory)
- [`terraform-google-network`](https://github.com/terraform-google-modules/terraform-google-network)
- [`terraform-kubernetes-engine`](https://github.com/terraform-google-modules/terraform-google-kubernetes-engine)

## CircleCI
See [Using Environment Variables](https://circleci.com/docs/2.0/env-vars/) for creating a new context called `meetup-demo` with the following variables:
- `GOOGLE_SA_KEY` - The output of your service account key
- `TF_VAR_admin_email` - The email address of the gsuite admin (for gsuite integration)
- `TF_VAR_organization_id` - The GCP organization id
- `TF_VAR_billing_account` - The GCP billing account
- `TF_VAR_group_name` - The gsuite group name to grant appropriate permissions

## Slide Deck
[Denver DevOps Meetup September 12, 2018](https://drive.google.com/open?id=12x7sys8ynFV66cw42VW1O43IFrqwxETdWa-qFYoUBcU)

## Asciinema Recording
[![asciicast](https://asciinema.org/a/FygCQHk8YHhAjaHpFU4de5o0s.png)](https://asciinema.org/a/FygCQHk8YHhAjaHpFU4de5o0s)
To play back in your local terminal run `asciinema play https://asciinema.org/a/FygCQHk8YHhAjaHpFU4de5o0s`

gha_language: HCL


text:
# skanr

Multithreaded network port scanner for IPV4 addresses

## requirements

1. known Target host IP Address

## installation

`pip install skanr`

## usage

### Help

Display the help

```
skanr -h
usage: skanr [-h] [-s] [-e] [-t] [--version] target_ip

Perform a network port scan of a host IP address

positional arguments:
  target_ip          Target IP address (xxx.xxx.xxx.xxx)

optional arguments:
  -h, --help         show this help message and exit
  -s , --startport   Port number to start scanning (default: 1)
  -e , --endport     End port number of scan range (default: 1024, max: 65535)
  -t , --threads     number of scan threads to run (default: 32, max: 1024)
  --version          prints version information
```

### basic IP scan

will scan an IP address from ports 1-1024 using 32 threads

```
skanr <IP_ADDRESS>

skanr v 0.0.1
Scanning IP: <IP_ADDRESS> ports: 1 - 1024 threads: 32
-=================================================================-
port 21 :open
port 23 :open
port 22 :open
port 53 :open
port 80 :open
port 110 :open
port 111 :open
port 139 :open
port 143 :open
port 445 :open
port 901 :open
```

### scan port range on target

To scan a port range on the target machine use `-s` and `-e` to specify the start and end ports

if no start ot end prot is given then defaults apply

```
skanr <IP_ADDRESS> -s 20 -e 100

skanr v 0.0.1
Scanning IP: <IP_ADDRESS> ports: 20 - 100 threads: 32
-=================================================================-
port 21 :open
port 22 :open
port 23 :open
port 53 :open
port 80 :open
```

### specifing threads

To speed up the port scanning the number of threads can be passed using the `-t` argument up to a max of 1024 threads, to prevent starting unwanted threads, the number of threads started will never be greater than the number of ports to be scanned.

```
skanr <IP_ADDRESS> -e 65535 -t 1024

skanr v 0.0.1
Scanning IP: <IP_ADDRESS> ports: 1 - 65535 threads: 1024
-=================================================================-
port 21 :open
port 22 :open
port 23 :open
port 53 :open
port 80 :open
port 110 :open
port 111 :open
port 139 :open
port 143 :open
port 445 :open
port 901 :open
port 2049 :open
port 6665 :open
port 6666 :open
port 6669 :open
port 6667 :open
port 6668 :open
port 8787 :open
port 37159 :open
port 44180 :open
port 50166 :open
```


text:
---
title: unins000.exe | Setup/Uninstall
excerpt: What is unins000.exe?
---

# unins000.exe

* File Path: `C:\Program Files\Microsoft VS Code\unins000.exe`
* Description: Setup/Uninstall
* Comments: This installation was built with Inno Setup.

## Hashes

Type | Hash
-- | --
MD5 | `9318C883BC05C372FF9475692414D712`
SHA1 | `6C8FA4A9F05B88FE6BE73882BEB757DBA515835E`
SHA256 | `8406DC72F045F45CC822F6229D089E21755433031743ADF438526C8E19719A2C`
SHA384 | `F9AFF748F559D041BC0C727D96F83E239DCA36231284D2E2F0DEF7465F6D9FA31F5B817721205D3CF3649B3C2B9E3E7A`
SHA512 | `D2648757A59AEC4F02708817606D120867E69B7EE0AFB9FE3145D0F2AEE2A5B9049F4E91996D77B4929478365E12A24998DBF90BA763D7F997A7B584476844B0`
SSDEEP | `49152:8R/KpmZubPf2S8W2ILeWl+C1p9jWy5Snd0eigXNh:K/jtYLP1Sy5E0w`

## Runtime Data

### Child Processes:
_iu14D2N.tmp

## Signature

* Status: Signature verified.
* Serial: `3300000187721772155940C709000000000187`
* Thumbprint: `2485A7AFA98E178CB8F30C9838346B514AEA4769`
* Issuer: CN=Microsoft Code Signing PCA 2011, O=Microsoft Corporation, L=Redmond, S=Washington, C=US
* Subject: CN=Microsoft Corporation, O=Microsoft Corporation, L=Redmond, S=Washington, C=US

## File Metadata

* Original Filename:
* Product Name: Visual Studio Code
* Company Name: Microsoft Corporation
* File Version: 51.1052.0.0
* Product Version: 1.48.0
* Language: Language Neutral
* Legal Copyright:

## File Similarity (ssdeep match)

File | Score
-- | --
[C:\Program Files (x86)\WinSCP\unins000.exe](unins000.exe-6AE472CF11968C09BBD88DE10C91F4ED.md) | 82
[C:\program files\GIMP 2\uninst\unins000.exe](unins000.exe-B034F4D564EF43DE2F65A0A4036E3336.md) | 97
[C:\program files\Microsoft VS Code\unins000.exe](unins000.exe-30F9E0633397507EB900C8593FAC704F.md) | 96
[C:\Program Files\Microsoft VS Code\unins000.exe](unins000.exe-630C9FB2DB921BD7C37628A7C9628D9E.md) | 99
[C:\Program Files\Microsoft VS Code\unins000.exe](unins000.exe-95FBFEEC649C6B9314AC31768B579CEE.md) | 96

MIT License. Copyright (c) 2020-2021 Strontic.


text:
This python client library allows easy access to [Edelweiss Data](https://edelweissdata.com) servers.

# Table of Contents

- [Overview](#overview)
- [Getting started](#getting-started)
  - [Requirements](#requirements)
  - [Installation](#installation)
- [Common use cases](#common-use-cases)
  - [Initialization](#initialization)
  - [Authentication](#authentication)
  - [Create a new dataset](#create-a-new-dataset)
  - [Search for datasets](#search-for-datasets)
  - [Filter and retrieve data](#filter-and-retrieve-data)
  - [Delete a new dataset](#delete-a-dataset)
- [API reference](#api-reference)

# Overview

The core concept of Edelweiss Data is that of a **Dataset**. A Dataset is a single table of data (usually originating from a csv file) and carries the following additional pieces of information:
* a **schema** describing the structure of the tabular data (data types, explanatory text for each column etc)
* a human readable **description text** (markdown formatted - like the readme of a repository on github)
* a **metadata json** structure (of arbitrary complexity - this can be used to store things like author information, instrument settings used to generate the data, ...).

Datasets are **versioned** through a processes called publishing. Once a version of a dataset is published, it is "frozen" and becomes immutable. Any change to it has to be done by creating a new version. Users of Edelweiss Data will always see the version history of a dataset and be able to ask for the latest version or specific earlier version.

Datasets can be public or **access restricted**. Public datasets can be accessed without any access restrictions. To access restricted datasets or to upload/edit your own dataset OpenIDConnect/OAuth is used - in the python client this process is done by calling the authenticate method on the Api instance that triggers a web based login at the end of which a token is confirmed.

When retrieving the tabular data of a dataset, the data can be **filtered and ordered** and only specific columns requested - this makes request for subsets of data much faster than if all filtering happened only on the client. Conditions for filtering and ordering are created by constructing QueryExpression instances using classmethods on the QueryExpression class to create specific Expressions. You can access the data either in it's raw form (as json data) or, more conveniently, as a Pandas Dataframe.

Just like the tabular data of one particular dataset can be retrieved as a **Pandas DataFrame**, you can also query for datasets using the same filtering and ordering capabilities - i.e. you can retrieve a DataFrame where each row represents a Dataset with it's name, description and optionally metadata and schema (not including the data though).

When you are searching for Datasets, a lot of the interesting information that you may want to filter by is hidden in the **metadata** (e.g. maybe most of your datasets have a metadata field "Species" at the top level of the metadata json that indicates from what kind of animal cells the data in this dataset originate from). To make such filtering easy, our Datasets query function take an optional list of "column mappings" that allow you to specify a **JsonPath expression** to extract a field from the metadata and include it with a given name in the resulting DataFrame. In the Species example, you could pass the list of column mappings [("Species from Metadata", "$.Species")] and the resulting DataFrame would contain an additional column "Species from Metadata" and for every row the result of evaluating the JsonPath $.Species would be included in this column and you could filter on it using conditions to e.g. only retrieve Datasets where the Species is set to "Mouse".

Edelweiss Data servers provide a rich **User Interface** as well that let's you visually browse and filter datasets and the data (and associated information) of each dataset. This UI is built to integrate nicely with the python client. The DataExplorer that is used to explore a dataset has a button in the upper right corner to generate the python code to get the exact same filtering and ordering you see in the UI into a Pandas DataFrame using the Edelweiss Data library for your convenience.

# More information and examples

The [official EdelweissData documentation](https://edelweissdata.com/docs/about) has more in-depth information about the various parts of EdelweissData.

In the [examples directory of the official documentation repository](https://github.com/DouglasConnect/edelweiss-data-docs/tree/master/example-notebooks) you can find several Jupyter notebooks which repeat the walkthroughs from the official EdelweissData documentation but using the edelweiss_data library instead of direct HTTP calls shown with JavaScript.

# Getting started

## Requirements

Python 3.6+

## Installation

```bash
pip install edelweiss_data
```

# Common use cases

In addition to the brief overview below, do check out the [examples directory of the official documentation repository](https://github.com/DouglasConnect/edelweiss-data-docs/tree/master/example-notebooks) that contains several Jupyter notebooks demonstrating common operations and showing e.g. all possible filter operators in use.

## Initialization

You interact with the Edelweiss Data API mainly via the API class of the edelweiss_data python library. Import it, point it at the Edelweiss Data instance you want to interact with and instantiate it like this:

```python
from edelweiss_data import API, QueryExpression as Q

# Set this to the url of the Edelweiss Data server you want to interact with
edelweiss_api_url = 'https://api.develop.edelweiss.douglasconnect.com'

api = API(edelweiss_api_url)

```

## Authentication

Some operations in Edelweiss Data are accessible without authentication (e.g. retrieving public datasets). For others (e.g. to create datasets), you need to be authenticated. Authentication is done with the authenticate call. Be aware that this call is currently built for interactive use like in a Jupyter environment - it will block execution for a up to a few minutes while it waits for you to log in to your account and confirm the access to the API on your behalf. Once accepted the python client will store the authentication token so that you will not have to enter it again for a few days (the token is stored in your home directory in the .edelweiss directory).

```python
api.authenticate()
```

## Create a new dataset

Creating and publishing a new dataset form a csv file can be done in one quick operation like so:

```python
metadata = {"metadata-dummy-string": "string value", "metadata-dummy-number": 42.0}
with open ('FILENAME') as f:
    dataset = api.create_published_dataset_from_csv_file("DATASETNAME", f, metadata)
```

This creates a new dataset form the file FILENAME with the name DATASETNAME. A trivial example metadata is used here as well.

When creating and publishing datasets like this you don't have a lot of control over details of the schema or to set a more elaborate dataset description. If you need more control, you can create a dataset like so:

```python
datafile = '../../tests/Serialization/data/small1.csv'
name = 'My dataset'
schemafile = None # if none, schema will be inferred below
metadata = None # dict object that will be serialized to json or None
metadatafile = None # path to the metadata file or None
description = "This is a *markdown* description that can use [hyperlinks](https://edelweissconnect.com)"

dataset1 = api.create_in_progress_dataset(name)
print('DATASET:', dataset1)
try:
    with open(datafile) as f:
        dataset1.upload_data(f)
    if schemafile is not None:
        print('uploading schema from file ...')
        with open(schemafile) as f:
            dataset1.upload_schema_file(f)
    else:
        print('inferring schema from file ...')
        dataset1.infer_schema()
    if metadata is not None:
        print('uploading metadata ...')
        dataset1.upload_metadata(metadata)
    elif metadatafile is not None:
        print('uploading metadata from file ...')
        with open(metadatafile) as f:
            dataset1.upload_metadata_file(f)

    dataset1.set_description(description)

    published_dataset = dataset1.publish('My first commit')
    print('DATASET published:',published_dataset)
except requests.HTTPError as err:
    print('not published: ', err.response.text)
```

## Filter and retrieve data

The tabular data of an individual dataset can be retrieved into a pandas dataframe easily like this:

```python
dataframe = dataset.get_data()
```

You can also filter and order data with QueryExpressions, often aliased to Q in the import statement. In the following example we assume the data to have a column "Species" which we want to filter to the value "Mouse" with fuzzy text matching and "Chemical name" which we want to order by ascending:

```python
dataframe = dataset.get_data(condition=Q.fuzzy_search(Q.column("Species"), "Mouse"), order_by=[Q.column("Chemical name")])
```

In this example you can see how to do a chemical substructure search so that only molecules with the fragment "CC=O" are returned and the results are sorted descending by similarity to the molecule "C(C(CO)(CO)N)O". Chemical similarity for ordering is calculated using the rdkit library using tanimoto distance between rdkit fingerprints (other fingerprints or distance metrics could be supported in the future)

```python
dataframe = dataset.get_data(condition=Q.substructure_search("CC=O", Q.column("SMILES")), order_by=[Q.tanimoto_similarity("C(C(CO)(CO)N)O", Q.column("SMILES"))], ascending=False)
```

## Search for datasets

To just retrieve a pandas dataframe with all published datasets that you are allowed to see use get_published_datasets(). This will return a pandas dataframe with a multiindex of the dataset id and version and then a single object column for the dataset class instance. This class instance can be used to retrieve e.g. the name property of the dataset or it can be used to retrieve the data for this dataset by calling the .get_data() method or similar operations.

```python
datasets = api.get_published_datasets()
dataset = datasets.iloc[0].dataset
print("Found {} datasets. The name of the first is: ".format(len(datasets), dataset.name))
```

To retrieve a single dataset by index value rather than based on numerical position use the pandas multiindex functionality passing in tuples:

```python
datasetid = '49fd99ee-ec6f-44df-a8cd-73f0f8bbcd76' # example dataset ID
version = 1
dataset = datasets.loc[(datasetid, version)]
```

Just like above with data you can use QueryExpressions to filter to only find datasets matching certain predicates. Below we filter on datasets that have the string "LTKB" somewhere in them (name etc)

```python
datasets_filter = Q.search_anywhere("LTKB")
datasets = api.get_published_datasets(condition=datasets_filter)
```

Since very often the most interesting filter and sort critieria will be in the metadata (which is a Json of arbitrary structure), the Api gives you a way to add additional columns by extracting pieces from the metadata json with JsonPath expressions. Below we attempt to treat the metadata json of each dataset as an object with a key "Species" and if it is present we extract it and map it into the "Species from metadata json" column:

```python
columns = [("Species from metadata json", "$.Species")]
datasets = api.get_published_datasets(columns=columns)
```

The result of such a query will always be a column containing lists of results as the jsonpath query could return not just a single primitive value or null or an object but also json arrays. Working with columns that contain lists in Pandas can be a bit awkward as some operations like filtering default to operating on series instead of individual cells. For cases like these, working with the Pandas apply method usually makes things easier - e.g. if you want to extract the first element if any from the above column this an easy way to do it that also extends well to more complex operations:

```python
datasets['first_species_or_none'] = datasets.apply(lambda row: row['Species from metadata json'][0] if len(row['Species from metadata json']) > 0 else None, axis=1)
```

## Delete a dataset

To delete a dataset and all versions call delete_all_versions:

```python
dataset.delete_all_versions()
```

# API reference

## `API`

The central interaction point with EdelweissData. You instantiate this class with the base url of the

EdelweissData server you want to interact with. The __init__ method will verify that the server is reachable
and speaks a compatible API version, then you can use instance methods to interact with the API server.

### `add_dataset_group_permission`

Add a group to a dataset

**dataset_id**  : *the id of the dataset*

**group**  : *the Group to add*

### `add_dataset_user_permission`

Add a user to a dataset

**dataset_id**  : *the id of the dataset*

**user**  : *the User to add*

### `authenticate`

### `change_dataset_visibility`

Set if the dataset should be public or access protected when published

**dataset_id**  : *the id of the dataset*

**is_public**  : *boolean to indicate if the dataset should be public*

### `create_in_progress_dataset`

Creates a new in-progress dataset on the server and returns it.

**Returns:** The InProgressDataset that was created.

**name**  : *the name of the dataset to create*

### `create_in_progress_dataset_from_csv_file`

Creates a new in-progress dataset from a CSV file on the server.

**Returns:** the updated dataset

**name**  : *the name of the dataset*

**file**  : *opened text file to read the csv data from*

**metadata**  : *dict of the metadata to store as json together with the dataset*

**description**  : *description text for the dataset (markdown formatted)*

**is_public**  : *flag to indicate if the dataset should be public or access restricted after publishing*

### `create_published_dataset_from_csv_file`

Creates a new published dataset from a CSV file on the server.

**Returns:** the published dataset

**name**  : *the name of the dataset*

**file**  : *opened text file to read the csv data from*

**metadata**  : *dict of the metadata to store as json together with the dataset*

**changelog**  : *Publishing message to store for the first version*

**description**  : *description text for the dataset (markdown formatted)*

**is_public**  : *flag to indicate if the dataset should be public or access restricted after publishing*

### `delete`

Sends a DELETE request to a server.

**Returns:** dict with the JSON response.

**route**  : *route to which the request will be sent*

### `get`

Sends a GET request to a server.

**Returns:** dict with the JSON response.

**route**  : *route to which the request will be sent*

**json**  : *dict with the JSON body to send*

### `get_dataset_permissions`

Get the permissions for the given dataset id

**Returns:** the DatasetPermissions instance for this dataset

**dataset_id**  : *the id of the dataset*

### `get_in_progress_dataset`

Returns an in-progress datasets with a given id.

**Returns:** an InProgressDataset

**id**  : *the id of the dataset to retrieve*

### `get_in_progress_datasets`

Returns a list of all in-progress datasets you are allowed to access (needs authentication).

**Returns:** a list of InProgressDatasets

**limit**  : *Number of datasets to retrieve - if None (default) it will retrieve all.*

**offset**  : *Starting offset from which to retrieve the datasets*

### `get_published_dataset`

Returns a published dataset with a given id and version.

**Returns:** the PublishedDataset

**id**  : *id of the dataset to retrieve*

**version**  : *version of the dataset to retrieve. Defaults to LATEST if none specified.*

### `get_published_dataset_aggregations`

Returns aggregation buckets and their sizes for each column.

**Returns:** aggregations as a Series with an index of buckets and terms, for example
bucket     term
organ      liver          10
           kidney         20
species    mouse           5
           elephant       30

**columns**  : *same as in self.get_published_datasets*

**condition**  : *same as in self.get_published_datasets*

**aggregation_filters**  : *same as in self.get_published_datasets*

### `get_published_dataset_versions`

Returns all published versions of dataset with a given id.

**Returns:** a list of PublishedDatasets

**id**  : *id of the dataset*

### `get_published_datasets`

Returns a dataframe of all published datasets that match query.

**Returns:** a dataframe indexed by the id and version, which in addition
to user-specified columns, contains a column with a PublishedDataset
object for each dataset. Unless included explicitly, description, schema,
and metadata are omitted from the datasets and the corresponding
attributes are set to None. On the first access to any of the missing
attributes of a given dataset, all three them are fetched from the server
and set to the actual values, resulting in a single request for each dataset.
If there are many datasets for which the attributes are required, it makes
sense to include the content in the bulk request.

**columns**  : *a list of pairs (column_name, json_path) describing
the name of the new column to generate and which jsonpath to use to
extract the values from the metadata to fill this column.*

**condition**  : *a QueryExpression object limiting the fetched datasets.*

**include_description**  : *a boolean specifying if the datasets in
the response should include the description*

**include_schema**  : *a boolean specifying if the datasets in
the response should include the schema*

**include_metadata**  : *a boolean specifying if the datasets in
the response should include the metadata*

**aggregation_filters**  : *a dict limiting the fetched datasets to ones
where column values fall into one of the selected aggregation buckets.
For example, using the dict
  {'organ': ['liver', 'kidney'], 'species': ['mouse', 'elephant']}
would return the datasets where both organ is either liver or kidney,
AND species is either mouse or elephant.*

**limit**  : *the number of rows to return.
Returns all rows if set to None (default).*

**offset**  : *the initial offset (default 0).*

**order_by**  : *a list of QueryExpression objects by which to order
the resulting datasets.*

**ascending**  : *a boolean or list of booleans to select the ordering.
If the single boolean is True (the default), the list is ascending
according to order_by, if False, it is descending. If given as a list,
it must be of the same length as the order_by list, and the order is
the ascending/descending for each particular component.*

**dataset_column_name**  : *the name of the dataframe column in which
the corresponding PublishedDataset objects are available.*

**latest_only**  : *a boolean specifying whether to return only the latest
version of each dataset*

### `get_raw_datasets`

Get the published datasets. Unlike the more high-level get_published_datasets this method

does not create a dataframe but returns the raw list of dicts representing the json response.
     Unless explicity included the fields schema, metadata and description will not be included
     in the response.

**Returns:** The published datasets as a list of dicts (raw json response)

**columns**  : *a list of pairs (column_name, json_path) describing
columns in the dataframe.*

**condition**  : *a QueryExpression object limiting the fetched datasets.*

**include_description**  : *a boolean specifying if the datasets in
the response should include the description*

**include_schema**  : *a boolean specifying if the datasets in
the response should include the schema*

**include_metadata**  : *a boolean specifying if the datasets in
the response should include the metadata*

**aggregation_filters**  : *a dict limiting the fetched datasets to ones
where column values fall into one of the selected aggregation buckets.
For example, using the dict
  {'organ': ['liver', 'kidney'], 'species': ['mouse', 'elephant']}
would return the datasets where both organ is either liver or kidney,
AND species is either mouse or elephant.*

**limit**  : *the number of rows to return (default 100).
Returns all rows if set to None.*

**offset**  : *the initial offset (default 0).*

**order_by**  : *a list of QueryExpression objects by which to order
the resulting datasets.*

**ascending**  : *a boolean or list of booleans to select the ordering.
If the single boolean is True (the default), the list is ascending
according to order_by, if False, it is descending. If given as a list,
it must be of the same length as the order_by list, and the order is
the ascending/descending for each particular component.*

**latest_only**  : *a boolean specifying whether to return only the latest
version of each dataset*

### `oidc_config`

Returns the OpenID Connect configuration.

### `openapi`

Returns the OpenAPI definition of the entire EdelweissData REST API.

**Returns:** The OpenAPI definition as a dict

### `openapi_documents`

Returns a list of all dataset specific openapi descriptions (i.e. one openapi document for each dataset with the

precise Json Schema of the particular datasets data endpoint).

**Returns:** A list of url strings at which to retrieve the openapi.json documents for the documents

### `post`

Sends a POST request to a server.

**Returns:** dict with the JSON response.

**route**  : *route to which the request will be sent*

**json**  : *dict with the JSON body to send*

### `post_raw`

Sends a POST request with a given body to a server.

**Returns:** dict with the JSON response.

**route**  : *route to which the request will be sent*

**body**  : *raw body to send (a bytes object or a string that will be encoded as UTF-8)*

### `remove_dataset_group_permission`

Remove a group from a dataset

**dataset_id**  : *the id of the dataset*

**name**  : *the name of the group to remove*

### `remove_dataset_user_permission`

Remove a user from a dataset

**dataset_id**  : *the id of the dataset*

**user**  : *the email of the user to remove*

### `upload`

Uploads a POST request that uploads files to a server.

**Returns:** dict with the JSON response.

**route**  : *route to which the request will be sent*

**files**  : *a dictionary of files in which the keys are filenames
and corresponding values are file objects*

## `DatasetPermissions`

The permission information for a dataset. A list of users (email + flag if they can write), groups (name + flag if they can write) and

an is_public field that indicates whether unauthenticated users can see this dataset when published.

### `Group`

#### `decode`

#### `encode`

### `User`

#### `decode`

#### `encode`

### `decode`

### `encode`

## `InProgressDataset`

InProgressDataset - datasets that are not yet published and for which data can be uploaded, the schema modified, metadata changed etc.

### `copy_from`

Copies all content from a PublishedDataset to this InProgressDataset. Useful to create new versions.

This is a lightweight operation, which works by re-using the same underlying data source.

### `decode`

### `delete`

Deletes the InProgressDataset

### `encode`

### `get_permissions`

### `infer_schema`

Triggers schema inference from uploaded data (this creates a schema on the server and sets it on the InProgressDataset)

### `publish`

Attempts to publish the dataset. This means that a new version of a PublishedDataset will be created (and returned by this call)

and this InProgressDataset is no longer useable.

### `sample`

Retrieve a list of lists representing a sample of the tabular data of this dataset. This

includes only a sample (e.g. the first N rows) of the data so that they can be displayed to a
user as an example or similar.

### `set_data_source`

Set the data source for an in-progress dataset. This allows you to efficiently re-use the data of a PublishedDataset

to create a new dataset without re-uploading the data. It is also useful if you want to create a new version of a
    PublishedDataset to fix a mistake in the metadata or description.

**dataset**  : *the PublishedDataset to copy data from when publishing*

### `set_description`

Set the description of the dataset. The description is assumed to be markdown formatted text, similar to a Github README.md

### `set_name`

Set the name of the dataset.

### `update`

Update various attributes of a in-progress dataset. All parameters are options; those that are

None will not have their values changed.

**name**  : *A new name for the dataset*

**description**  : *A new description for the dataset*

**data_source**  : *A new data_source for the dataset. See set_data_source for a description of a data source.*

**schema**  : *A new schema for the dataset.*

**metadata**  : *A new metadata object for the dataset.*

### `upload_data`

Upload tabular data (a CSV file)

**data**  : *An open text file containing the csv data to upload*

### `upload_dataframe_data`

Upload a pandas dataframe as the data content into an InProgress dataset

**dataframe**  : *A Pandas dataframe containing the data to upload*

### `upload_metadata`

Upload metadata (as a dict, not a file).

**schema**  : *The metadata to upload*

### `upload_metadata_file`

Upload a metadata file (an open text file containing the metadata in Json form).

**file**  : *The open text file to upload the metadata from*

### `upload_schema`

Upload a Schema (an instance of the class, not a file).

**schema**  : *The schema to upload*

### `upload_schema_file`

Upload a schema file (an open text file containing the schema in Json form).

**file**  : *The open text file to upload the schema from*

## `PublishedDataset`

Represents a published dataset

### `decode`

### `delete_all_versions`

Deletes all versions of a published dataset

### `encode`

### `get_data`

Gets the (tabular) data of a PublishedDataset as a pandas Dataframe. The data can be filtered so that only required columns or rows

are retrieved.

**Returns:** A pandas DataFrame with the tabular data

**columns**  : *a list of column names that should appear in the result.
If None, all columns are included.*

**condition**  : *a QueryExpression object limiting the fetched datasets.*

**aggregation_filters**  : *a dict limiting the fetched datasets to ones
where column values fall into one of the selected aggregation buckets.
For example, using the dict
  {'organ': ['liver', 'kidney'], 'species': ['mouse', 'elephant']}
would return the datasets where both organ is either liver or kidney,
AND species is either mouse or elephant.*

**limit**  : *the number of rows to return.
Returns all rows if set to None (default).*

**offset**  : *the initial offset (default 0).*

**order_by**  : *a list of QueryExpression objects by which to order
the resulting datasets.*

**ascending**  : *a boolean or list of booleans to select the ordering.
If the single boolean is True (the default), the list is ascending
according to order_by, if False, it is descending. If given as a list,
it must be of the same length as the order_by list, and the order is
the ascending/descending for each particular component.*

### `get_data_aggregations`

Returns aggregation buckets and their sizes for each column.

**Returns:** aggregations as a Series with an index of buckets and terms, for example
bucket     term
organ      liver          10
           kidney         20
species    mouse           5
           elephant       30

**columns**  : *a list of column names that should appear in the result.
If None, all columns are included.*

**condition**  : *a QueryExpression object limiting the fetched datasets.*

**aggregation_filters**  : *a dict limiting the fetched datasets to ones
where column values fall into one of the selected aggregation buckets.
For example, using the dict
  {'organ': ['liver', 'kidney'], 'species': ['mouse', 'elephant']}
would return the datasets where both organ is either liver or kidney,
AND species is either mouse or elephant.*

### `get_permissions`

Returns the Permissions object of this PublishedDataset

### `get_raw_data`

Gets the raw tabular data JSON response for a PublishedDataset. The data can be filtered so that only required columns or rows

are retrieved.

**Returns:** A dict representing the JSON response

**columns**  : *a list of column names that should appear in the result.
If None, all columns are included.*

**condition**  : *a QueryExpression object limiting the fetched datasets.*

**aggregation_filters**  : *a dict limiting the fetched datasets to ones
where column values fall into one of the selected aggregation buckets.
For example, using the dict
  {'organ': ['liver', 'kidney'], 'species': ['mouse', 'elephant']}
would return the datasets where both organ is either liver or kidney,
AND species is either mouse or elephant.*

**limit**  : *the number of rows to return.
Returns all rows if set to None (default).*

**offset**  : *the initial offset (default 0).*

**order_by**  : *a list of QueryExpression objects by which to order
the resulting datasets.*

**ascending**  : *a boolean or list of booleans to select the ordering.
If the single boolean is True (the default), the list is ascending
according to order_by, if False, it is descending. If given as a list,
it must be of the same length as the order_by list, and the order is
the ascending/descending for each particular component.*

### `new_version`

Create a new version of this PublishedDataset. This will create and return a new InProgressDataset

that can be filled with content by uploading new files or copying data from a PublishedDataset

**Returns:** The InProgressDataset

### `openapi`

Returns a OpenAPI descriptions for the data endpoint of this PublishedDataset, taking the schema

and thus the precise JSON structure of the response into account.

**Returns:** A dict respresenting the JSON decoded OpenAPI document

## `QueryExpression`

Used to create filters or expressions to order records by. Use the classmethods on this

class to create instances, e.g. QueryExpression.fuzzySearch(QueryExpression.column("species"), "Monkey")

### `cast`

Creates a Cast expression. This attempts to convert one datatype into another.

**expr**  : *The expression to cast*

**data_type**  : *The datatype to cast to*

### `column`

Constructs a Column expression.

**column_name**  : *the name of the column*

### `contained_in`

Creates a ContainedIn expression. Tests if an expression is contained in an element. Often used

to check if columns of an Array datatype are contained in a value.

**expr**  : *The expression to search for*

**element**  : *The element to search in*

### `contains`

Creates a Contains expression. Tests if an expression contains an element. Often used

to check if columns of an Array datatype contain a value.

**expr**  : *The expression to search in*

**element**  : *The element to search for*

### `decode`

### `encode`

### `exact_search`

Constructs an ExactSearch expression. Only rows where the expr expression exactly matches the term will be returned. This can be used

to match exact substrings or exact numerical values

**expr**  : *the search expression to evaluate (often a column QueryExpression)*

**term**  : *the search term*

### `fuzzy_search`

Constructs a FuzzySearch expression. Only rows where the expr expression fuzzy-matches the term will be returned. Fuzzy-matching

uses trigram indexing to match slightly different spellings.

**expr**  : *the search expression to evaluate (often a column QueryExpression)*

**term**  : *the search term*

### `search_anywhere`

Constructs a SearchAnywhere expression. Only rows will be returned that contain the search term in one of their text-like columns.

**term**  : *The string to search for in all text-like columns.*

### `substructure_search`

Constructs a SubstructureSearch expression that uses chemical substructure testing. Only rows where the chemical substructure is contained in

the chemical superstructure are returned.

**substructure**  : *the substructure to search (often a SMILES string constant value)*

**superstructure**  : *the search term (often a Column of datatype SMILES)*

### `system_column`

Constructs a SystemColumn expression. SystemColumns are special columns maintained by EdelweissData.

The following SystemColumns are available:
        name (text): the name of a dataset
        created (text/datetime): the timestamp the dataset was created at
        version: (int): the version number of the dataset

**column_name**  : *the name of the column*

### `tanimoto_similarity`

Calculates the tanimoto distance between two molecular fingerprints.

**left**  : *the left argument. Often a SMILES string constant value or Column of datatype SMILES.*

**right**  : *the right argument. Often a SMILES string constant value or Column of datatype SMILES.*

## `Schema`

The schema of the dataset describing the columns (name, description, datatype, rdf predicate, ...)

### `Column`

The schema data of one column. This tells EdelweissData the name of the column, the datatype to use, how to handle missing values, ...

#### `decode`

#### `encode`

### `decode`

### `encode`

## `cast`

Cast a value to a type.

This returns the value unchanged.  To the type checker this
signals that the return value has the designated type, but at
runtime we intentionally don't check anything (we want this
to be as fast as possible).

repository: DouglasConnect/edelweiss-data-python

gha_language: Python

repo_name: DouglasConnect/edelweiss-data-python


text:
# proio for C++
[![Build Status](https://travis-ci.org/proio-org/cpp-proio.svg?branch=master)](https://travis-ci.org/proio-org/cpp-proio)
[![codecov](https://codecov.io/gh/proio-org/cpp-proio/branch/master/graph/badge.svg)](https://codecov.io/gh/proio-org/cpp-proio)
[![Codacy Badge](https://api.codacy.com/project/badge/Grade/ad338e9f8dad4cdbb54d664a742f3a81)](https://www.codacy.com/app/proio-org/cpp-proio?utm_source=github.com&utm_medium=referral&utm_content=proio-org/cpp-proio&utm_campaign=Badge_Grade)

Proio is an event-oriented streaming data format based on Google's [protocol
buffers](https://developers.google.com/protocol-buffers/) (protobuf).  Proio
aims to add event structure and additional compression to protobuf in a way
that supports event data model serialization in medium- and high-energy
physics.  Additionally, proio
* supports self-descriptive data,
* is stream compatible,
* is language agnostic,
* and brings along many advantages of protobuf, including forward/backward
  compatibility.

For detailed information on the proio format and introductory information on
the software implementations, please see [DOI
10.1016/j.cpc.2019.03.018](https://doi.org/10.1016/j.cpc.2019.03.018).  This
work was inspired and influenced by [LCIO](https://github.com/iLCSoft/LCIO),
ProMC (Sergei Chekanov), and EicMC (Alexander Kiselev)

Also see the [main proio repository](https://github.com/proio-org/proio) for
additional information information.

## API
The API documentation is generated using Doxygen, and can be found
[here](https://proio-org.github.io/cpp-proio-docs/).

## Installation
### Requirements
* Protobuf 3.1+
* LZ4 1.8+

### Building the code
First thing to note is that cpp-proio uses git submodules to pull in the
language-independent proio files.  This means that you will have to initialize
and pull the submodule.
```shell
git submodule update --init
```

Once, the proio submodule is up-to-date, standard CMake practices apply, so
make sure you have CMake installed.  Create a build directory (e.g.
cpp-proio/build), and `cd` into it.  Then, run `cmake` on the directory with
`CMakeLists.txt` (this directory).
```shell
mkdir build
cd build
cmake ../
make
make test
sudo make install
```

If you need to point CMake to dependencies in non-standard locations, please
set the
[`CMAKE_PREFIX_PATH`](https://cmake.org/cmake/help/v3.0/variable/CMAKE_PREFIX_PATH.html)
variable.  For example, if you build and install the required Protobuf and LZ4
libraries into subdirectories of `/opt`, your `cmake` command might look like
the following:
```shell
cmake \
    -DCMAKE_PREFIX_PATH="/opt/protobuf;/opt/lz4" \
    -DCMAKE_INSTALL_PREFIX=/opt/proio \
    ../
```

### Installing LZ4 from github
The following installs to the default installation prefix.
```
git clone https://github.com/lz4/lz4.git && cd lz4
make cmake
sudo cmake --build contrib/cmake_unofficial/.  -- install
```

repository: proio-org/cpp-proio

repo_name: proio-org/cpp-proio