new era

README.md

@@ -2,34 +2,12 @@
 license: other
 license_name: notouch
 license_link: LICENSE
-train-eval-index:
-  - config: default
-    task: summarization
-    task_id: summarization
-    splits:
-      eval_split: test
-    col_mapping:
-      article: text
-      highlights: target
-dataset_info:
+configs:
 - config_name: default
-  features:
-  - name: article
-    dtype: string
-  - name: highlights
-    dtype: string
-  - name: id
-    dtype: string
-  splits:
-  - name: train
-    num_bytes: 5814
-    num_examples: 1
-  - name: test
-    num_bytes: 8163
-    num_examples: 1
-  download_size: 10818
-  dataset_size: 13977
-
+  data_files:
+  - split: train
+    path: "data/train.csv"
 ---
 
-
+# Readme
+hello!

data/test-00000-of-00001-f91988ac178fc28b.parquet

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:75ae32f3fa62a243ccc1aabb0f27ea5a5427dd3320ac2d9f6750858632bdc2e9
-size 5457

data/train-00000-of-00001-2973c5ddf9961df5.parquet

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:1afac1dc0374b579357c6f97712eb2229e088db15a6710a812c54aa36a37f1e1
-size 4925

data/train.csv

@@ -0,0 +1,525 @@
+,path,environment,text,id
+0,environment/env.go,"[""LOCALHOST_IP"", ""CASSANDRA_SEEDS"", ""CASSANDRA_PORT"", ""MYSQL_SEEDS"", ""MYSQL_PORT"", ""ES_SEEDS"", ""ES_PORT"", ""ES_VERSION"", ""POSTGRES_SEEDS"", ""POSTGRES_PORT""]","// The MIT License
+//
+// Copyright (c) 2020 Temporal Technologies Inc.  All rights reserved.
+//
+// Copyright (c) 2020 Uber Technologies, Inc.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the ""Software""), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED ""AS IS"", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
+package environment
+
+import (
+	""fmt""
+	""net""
+	""os""
+	""strconv""
+)
+
+const (
+	// LocalhostIP default localhost
+	LocalhostIP = ""LOCALHOST_IP""
+	// Localhost default hostname
+	LocalhostIPDefault = ""127.0.0.1""
+
+	// CassandraSeeds env
+	CassandraSeeds = ""CASSANDRA_SEEDS""
+	// CassandraPort env
+	CassandraPort = ""CASSANDRA_PORT""
+	// CassandraDefaultPort Cassandra default port
+	CassandraDefaultPort = 9042
+
+	// MySQLSeeds env
+	MySQLSeeds = ""MYSQL_SEEDS""
+	// MySQLPort env
+	MySQLPort = ""MYSQL_PORT""
+	// MySQLDefaultPort MySQL default port
+	MySQLDefaultPort = 3306
+
+	// ESSeeds env
+	ESSeeds = ""ES_SEEDS""
+	// ESPort env
+	ESPort = ""ES_PORT""
+	// ESDefaultPort ES default port
+	ESDefaultPort = 9200
+	// ESVersion is the ElasticSearch version
+	ESVersion = ""ES_VERSION""
+	// ESDefaultVersion is the default version
+	ESDefaultVersion = ""v7""
+
+	// PostgresSeeds env
+	PostgresSeeds = ""POSTGRES_SEEDS""
+	// PostgresPort env
+	PostgresPort = ""POSTGRES_PORT""
+	// PostgresDefaultPort Postgres default port
+	PostgresDefaultPort = 5432
+)
+
+type varSpec struct {
+	name       string
+	getDefault func() string
+}
+
+var envVars = []varSpec{
+	{
+		name:       LocalhostIP,
+		getDefault: func() string { return lookupLocalhostIP(""localhost"") },
+	},
+	{
+		name:       CassandraSeeds,
+		getDefault: GetLocalhostIP,
+	},
+	{
+		name:       CassandraPort,
+		getDefault: func() string { return strconv.Itoa(CassandraDefaultPort) },
+	},
+	{
+		name:       MySQLSeeds,
+		getDefault: GetLocalhostIP,
+	},
+	{
+		name:       MySQLPort,
+		getDefault: func() string { return strconv.Itoa(MySQLDefaultPort) },
+	},
+	{
+		name:       PostgresSeeds,
+		getDefault: GetLocalhostIP,
+	},
+	{
+		name:       PostgresPort,
+		getDefault: func() string { return strconv.Itoa(PostgresDefaultPort) },
+	},
+	{
+		name:       ESSeeds,
+		getDefault: GetLocalhostIP,
+	},
+	{
+		name:       ESPort,
+		getDefault: func() string { return strconv.Itoa(ESDefaultPort) },
+	},
+	{
+		name:       ESVersion,
+		getDefault: func() string { return ESDefaultVersion },
+	},
+}
+
+// SetupEnv setup the necessary env
+func SetupEnv() {
+	for _, envVar := range envVars {
+		if os.Getenv(envVar.name) == """" {
+			if err := os.Setenv(envVar.name, envVar.getDefault()); err != nil {
+				panic(fmt.Sprintf(""error setting env var %s: %s"", envVar.name, err))
+			}
+		}
+	}
+}
+
+func lookupLocalhostIP(domain string) string {
+	// lookup localhost and favor the first ipv4 address
+	// unless there are only ipv6 addresses available
+	ips, err := net.LookupIP(domain)
+	if err != nil || len(ips) == 0 {
+		// fallback to default instead of error
+		return LocalhostIPDefault
+	}
+	var listenIp net.IP
+	for _, ip := range ips {
+		listenIp = ip
+		if listenIp.To4() != nil {
+			break
+		}
+	}
+	return listenIp.String()
+}
+
+// GetLocalhostIP returns the ip address of the localhost domain
+func GetLocalhostIP() string {
+	localhostIP := os.Getenv(LocalhostIP)
+	ip := net.ParseIP(localhostIP)
+	if ip != nil {
+		// if localhost is an ip return it
+		return ip.String()
+	}
+	// otherwise, ignore the value and lookup `localhost`
+	return lookupLocalhostIP(""localhost"")
+}
+
+// GetCassandraAddress return the cassandra address
+func GetCassandraAddress() string {
+	addr := os.Getenv(CassandraSeeds)
+	if addr == """" {
+		addr = GetLocalhostIP()
+	}
+	return addr
+}
+
+// GetCassandraPort return the cassandra port
+func GetCassandraPort() int {
+	port := os.Getenv(CassandraPort)
+	if port == """" {
+		return CassandraDefaultPort
+	}
+	p, err := strconv.Atoi(port)
+	if err != nil {
+		panic(fmt.Sprintf(""error getting env %v"", CassandraPort))
+	}
+	return p
+}
+
+// GetMySQLAddress return the cassandra address
+func GetMySQLAddress() string {
+	addr := os.Getenv(MySQLSeeds)
+	if addr == """" {
+		addr = GetLocalhostIP()
+	}
+	return addr
+}
+
+// GetMySQLPort return the MySQL port
+func GetMySQLPort() int {
+	port := os.Getenv(MySQLPort)
+	if port == """" {
+		return MySQLDefaultPort
+	}
+	p, err := strconv.Atoi(port)
+	if err != nil {
+		panic(fmt.Sprintf(""error getting env %v"", MySQLPort))
+	}
+	return p
+}
+
+// GetPostgreSQLAddress return the cassandra address
+func GetPostgreSQLAddress() string {
+	addr := os.Getenv(PostgresSeeds)
+	if addr == """" {
+		addr = GetLocalhostIP()
+	}
+	return addr
+}
+
+// GetPostgreSQLPort return the Postgres port
+func GetPostgreSQLPort() int {
+	port := os.Getenv(PostgresPort)
+	if port == """" {
+		return PostgresDefaultPort
+	}
+	p, err := strconv.Atoi(port)
+	if err != nil {
+		panic(fmt.Sprintf(""error getting env %v"", PostgresPort))
+	}
+	return p
+}
+",8da30a84-46e2-434a-9df9-4fc9ab89a897
+1,common/log/zap_logger.go,"[""TEMPORAL_TEST_LOG_FORMAT"", ""TEMPORAL_TEST_LOG_LEVEL""]","// The MIT License
+//
+// Copyright (c) 2020 Temporal Technologies Inc.  All rights reserved.
+//
+// Copyright (c) 2020 Uber Technologies, Inc.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the ""Software""), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED ""AS IS"", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
+package log
+
+import (
+	""os""
+	""path/filepath""
+	""runtime""
+	""strconv""
+	""strings""
+
+	""go.uber.org/zap""
+	""go.uber.org/zap/zapcore""
+
+	""go.temporal.io/server/common/log/tag""
+)
+
+const (
+	skipForZapLogger = 3
+	// we put a default message when it is empty so that the log can be searchable/filterable
+	defaultMsgForEmpty  = ""none""
+	testLogFormatEnvVar = ""TEMPORAL_TEST_LOG_FORMAT"" // set to ""json"" for json logs in tests
+	testLogLevelEnvVar  = ""TEMPORAL_TEST_LOG_LEVEL""  // set to ""debug"" for debug level logs in tests
+)
+
+type (
+	// zapLogger is logger backed up by zap.Logger.
+	zapLogger struct {
+		zl   *zap.Logger
+		skip int
+	}
+)
+
+var _ Logger = (*zapLogger)(nil)
+
+// NewTestLogger returns a logger for tests
+func NewTestLogger() *zapLogger {
+	format := os.Getenv(testLogFormatEnvVar)
+	if format == """" {
+		format = ""console""
+	}
+
+	logger := BuildZapLogger(Config{
+		Level:       os.Getenv(testLogLevelEnvVar),
+		Format:      format,
+		Development: true,
+	})
+
+	// Don't include stack traces for warnings during tests. Only include them for logs with level error and above.
+	logger = logger.WithOptions(zap.AddStacktrace(zap.ErrorLevel))
+
+	return NewZapLogger(logger)
+}
+
+// NewCLILogger returns a logger at debug level and log into STDERR for logging from within CLI tools
+func NewCLILogger() *zapLogger {
+	return NewZapLogger(buildCLIZapLogger())
+}
+
+// NewZapLogger returns a new zap based logger from zap.Logger
+func NewZapLogger(zl *zap.Logger) *zapLogger {
+	return &zapLogger{
+		zl:   zl,
+		skip: skipForZapLogger,
+	}
+}
+
+// BuildZapLogger builds and returns a new zap.Logger for this logging configuration
+func BuildZapLogger(cfg Config) *zap.Logger {
+	return buildZapLogger(cfg, true)
+}
+
+func caller(skip int) string {
+	_, path, line, ok := runtime.Caller(skip)
+	if !ok {
+		return """"
+	}
+	return filepath.Base(path) + "":"" + strconv.Itoa(line)
+}
+
+func (l *zapLogger) buildFieldsWithCallAt(tags []tag.Tag) []zap.Field {
+	fields := make([]zap.Field, len(tags)+1)
+	l.fillFields(tags, fields)
+	fields[len(fields)-1] = zap.String(tag.LoggingCallAtKey, caller(l.skip))
+	return fields
+}
+
+// fillFields fill fields parameter with fields read from tags. Optimized for performance.
+func (l *zapLogger) fillFields(tags []tag.Tag, fields []zap.Field) {
+	for i, t := range tags {
+		if zt, ok := t.(tag.ZapTag); ok {
+			fields[i] = zt.Field()
+		} else {
+			fields[i] = zap.Any(t.Key(), t.Value())
+		}
+	}
+}
+
+func setDefaultMsg(msg string) string {
+	if msg == """" {
+		return defaultMsgForEmpty
+	}
+	return msg
+}
+
+func (l *zapLogger) Debug(msg string, tags ...tag.Tag) {
+	if l.zl.Core().Enabled(zap.DebugLevel) {
+		msg = setDefaultMsg(msg)
+		fields := l.buildFieldsWithCallAt(tags)
+		l.zl.Debug(msg, fields...)
+	}
+}
+
+func (l *zapLogger) Info(msg string, tags ...tag.Tag) {
+	if l.zl.Core().Enabled(zap.InfoLevel) {
+		msg = setDefaultMsg(msg)
+		fields := l.buildFieldsWithCallAt(tags)
+		l.zl.Info(msg, fields...)
+	}
+}
+
+func (l *zapLogger) Warn(msg string, tags ...tag.Tag) {
+	if l.zl.Core().Enabled(zap.WarnLevel) {
+		msg = setDefaultMsg(msg)
+		fields := l.buildFieldsWithCallAt(tags)
+		l.zl.Warn(msg, fields...)
+	}
+}
+
+func (l *zapLogger) Error(msg string, tags ...tag.Tag) {
+	if l.zl.Core().Enabled(zap.ErrorLevel) {
+		msg = setDefaultMsg(msg)
+		fields := l.buildFieldsWithCallAt(tags)
+		l.zl.Error(msg, fields...)
+	}
+}
+
+func (l *zapLogger) DPanic(msg string, tags ...tag.Tag) {
+	if l.zl.Core().Enabled(zap.DPanicLevel) {
+		msg = setDefaultMsg(msg)
+		fields := l.buildFieldsWithCallAt(tags)
+		l.zl.DPanic(msg, fields...)
+	}
+}
+
+func (l *zapLogger) Panic(msg string, tags ...tag.Tag) {
+	if l.zl.Core().Enabled(zap.PanicLevel) {
+		msg = setDefaultMsg(msg)
+		fields := l.buildFieldsWithCallAt(tags)
+		l.zl.Panic(msg, fields...)
+	}
+}
+
+func (l *zapLogger) Fatal(msg string, tags ...tag.Tag) {
+	if l.zl.Core().Enabled(zap.FatalLevel) {
+		msg = setDefaultMsg(msg)
+		fields := l.buildFieldsWithCallAt(tags)
+		l.zl.Fatal(msg, fields...)
+	}
+}
+
+func (l *zapLogger) With(tags ...tag.Tag) Logger {
+	fields := make([]zap.Field, len(tags))
+	l.fillFields(tags, fields)
+	zl := l.zl.With(fields...)
+	return &zapLogger{
+		zl:   zl,
+		skip: l.skip,
+	}
+}
+
+func (l *zapLogger) Skip(extraSkip int) Logger {
+	return &zapLogger{
+		zl:   l.zl,
+		skip: l.skip + extraSkip,
+	}
+}
+
+func buildZapLogger(cfg Config, disableCaller bool) *zap.Logger {
+	encodeConfig := zapcore.EncoderConfig{
+		TimeKey:        ""ts"",
+		LevelKey:       ""level"",
+		NameKey:        ""logger"",
+		CallerKey:      zapcore.OmitKey, // we use our own caller
+		FunctionKey:    zapcore.OmitKey,
+		MessageKey:     ""msg"",
+		StacktraceKey:  ""stacktrace"",
+		LineEnding:     zapcore.DefaultLineEnding,
+		EncodeLevel:    zapcore.LowercaseLevelEncoder,
+		EncodeTime:     zapcore.ISO8601TimeEncoder,
+		EncodeDuration: zapcore.SecondsDurationEncoder,
+		EncodeCaller:   zapcore.ShortCallerEncoder,
+	}
+	if disableCaller {
+		encodeConfig.CallerKey = zapcore.OmitKey
+		encodeConfig.EncodeCaller = nil
+	}
+
+	outputPath := ""stderr""
+	if len(cfg.OutputFile) > 0 {
+		outputPath = cfg.OutputFile
+	}
+	if cfg.Stdout {
+		outputPath = ""stdout""
+	}
+	encoding := ""json""
+	if cfg.Format == ""console"" {
+		encoding = ""console""
+	}
+	config := zap.Config{
+		Level:            zap.NewAtomicLevelAt(parseZapLevel(cfg.Level)),
+		Development:      cfg.Development,
+		Sampling:         nil,
+		Encoding:         encoding,
+		EncoderConfig:    encodeConfig,
+		OutputPaths:      []string{outputPath},
+		ErrorOutputPaths: []string{outputPath},
+		DisableCaller:    disableCaller,
+	}
+	logger, _ := config.Build()
+	return logger
+}
+
+func buildCLIZapLogger() *zap.Logger {
+	encodeConfig := zapcore.EncoderConfig{
+		TimeKey:        ""ts"",
+		LevelKey:       ""level"",
+		NameKey:        ""logger"",
+		CallerKey:      zapcore.OmitKey, // we use our own caller
+		FunctionKey:    zapcore.OmitKey,
+		MessageKey:     ""msg"",
+		StacktraceKey:  ""stacktrace"",
+		LineEnding:     zapcore.DefaultLineEnding,
+		EncodeLevel:    zapcore.CapitalColorLevelEncoder,
+		EncodeTime:     zapcore.ISO8601TimeEncoder,
+		EncodeDuration: zapcore.SecondsDurationEncoder,
+		EncodeCaller:   nil,
+	}
+
+	config := zap.Config{
+		Level:             zap.NewAtomicLevelAt(zap.DebugLevel),
+		Development:       false,
+		DisableStacktrace: os.Getenv(""TEMPORAL_CLI_SHOW_STACKS"") == """",
+		Sampling:          nil,
+		Encoding:          ""console"",
+		EncoderConfig:     encodeConfig,
+		OutputPaths:       []string{""stderr""},
+		ErrorOutputPaths:  []string{""stderr""},
+		DisableCaller:     true,
+	}
+	logger, _ := config.Build()
+	return logger
+}
+
+func parseZapLevel(level string) zapcore.Level {
+	switch strings.ToLower(level) {
+	case ""debug"":
+		return zap.DebugLevel
+	case ""info"":
+		return zap.InfoLevel
+	case ""warn"":
+		return zap.WarnLevel
+	case ""error"":
+		return zap.ErrorLevel
+	case ""dpanic"":
+		return zap.DPanicLevel
+	case ""panic"":
+		return zap.PanicLevel
+	case ""fatal"":
+		return zap.FatalLevel
+	default:
+		return zap.InfoLevel
+	}
+}
+",3cbadd97-dd06-4d85-8e23-d8472db56cf4

data/validation-00000-of-00001-a4abb009e9810b24.parquet

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:04488d97d9ec51184e531ed450e9bf5e101fbffabbb5dfb304e632283d731578
-size 436