diff --git a/CHANGELOG b/CHANGELOG
index 28e66fb556..edaa870de3 100644
--- a/CHANGELOG
+++ b/CHANGELOG
@@ -1,3 +1,5 @@
+* Unify PYSON string format
+
 Version 5.8.0 - 2020-11-02
 * Bug fixes (see mercurial logs for details)
 * Format timedelta in CSV export
diff --git a/src/pyson.js b/src/pyson.js
index f3db5f5707..32e035a029 100644
--- a/src/pyson.js
+++ b/src/pyson.js
@@ -4,7 +4,10 @@
     'use strict';
 
     Sao.PYSON = {};
-    Sao.PYSON.eval = {};
+    Sao.PYSON.eval = {
+        True: true,
+        False: false,
+    };
     Sao.PYSON.toString = function(value) {
         if (value instanceof Sao.PYSON.PYSON) {
             return value.toString();
@@ -263,13 +266,11 @@
 
 
     Sao.PYSON.eval.And = function(statements) {
-        return new Sao.PYSON.And(statements);
+        return Sao.PYSON.And.new_(statements);
     };
     Sao.PYSON.And = Sao.class_(Sao.PYSON.PYSON, {
-        init: function(statements) {
-            if (statements === undefined) {
-                statements = [];
-            }
+        init: function() {
+            var statements = jQuery.extend([], arguments);
             Sao.PYSON.And._super.init.call(this);
             for (var i = 0, len = statements.length; i < len; i++) {
                 var statement = statements[i];
@@ -297,7 +298,7 @@
             return ['boolean'];
         },
         __string_params__: function() {
-            return [this._statements];
+            return this._statements;
         }
     });
 
@@ -310,12 +311,12 @@
         return result;
     };
     Sao.PYSON.And.init_from_object = function(obj) {
-        return new Sao.PYSON.And(obj.s);
+        return Sao.PYSON.And.new_(obj.s);
     };
 
 
     Sao.PYSON.eval.Or = function(statements) {
-        return new Sao.PYSON.Or(statements);
+        return Sao.PYSON.Or.new_(statements);
     };
     Sao.PYSON.Or = Sao.class_(Sao.PYSON.And, {
         pyson: function() {
@@ -334,7 +335,7 @@
         return result;
     };
     Sao.PYSON.Or.init_from_object= function(obj) {
-        return new Sao.PYSON.Or(obj.s);
+        return new Sao.PYSON.Or.new_(obj.s);
     };
 
     Sao.PYSON.eval.Equal = function(statement1, statement2) {
diff --git a/src/sao.js b/src/sao.js
index bf49bb3c6d..93319447a5 100644
--- a/src/sao.js
+++ b/src/sao.js
@@ -163,6 +163,15 @@ var Sao = {};
                     Object.getOwnPropertyDescriptor(props, name));
             }
         }
+
+        // Method to create new instance with a list of arguments
+        function F(args) {
+            return ClassConstructor.apply(this, args);
+        }
+        F.prototype = ClassConstructor.prototype;
+        ClassConstructor.new_ = function(args) {
+            return new F(args);
+        };
         return ClassConstructor;
     };
 
diff --git a/tests/sao.js b/tests/sao.js
index c12ebdde35..510d7bcddf 100644
--- a/tests/sao.js
+++ b/tests/sao.js
@@ -189,139 +189,133 @@
     });
 
     QUnit.test('PYSON And', function() {
-        var value = new Sao.PYSON.And([true, false]).pyson();
-        QUnit.strictEqual(value.__class__, 'And', 'And([true, false]).pyson()');
+        var value = new Sao.PYSON.And(true, false).pyson();
+        QUnit.strictEqual(value.__class__, 'And', 'And(true, false).pyson()');
         QUnit.ok(Sao.common.compare(value.s, [true, false]),
             'And([true, false]).pyson()');
 
         QUnit.throws(function() {
-            new Sao.PYSON.And([true]);
-        }, 'must have at least 2 statements', 'And([true])');
-        QUnit.throws(function() {
-            new Sao.PYSON.And([]);
-        }, 'must have at least 2 statements', 'And([])');
+            new Sao.PYSON.And(true);
+        }, 'must have at least 2 statements', 'And(true)');
         QUnit.throws(function() {
             new Sao.PYSON.And();
         }, 'must have at least 2 statements', 'And()');
 
-        QUnit.ok(Sao.common.compare(new Sao.PYSON.And([true, false]).types(),
-                    ['boolean']), 'And([true, false]).types()');
+        QUnit.ok(Sao.common.compare(new Sao.PYSON.And(true, false).types(),
+                    ['boolean']), 'And(true, false).types()');
 
         var eval_;
         eval_ = new Sao.PYSON.Encoder().encode(
-                new Sao.PYSON.And([true, true]));
+                new Sao.PYSON.And(true, true));
         QUnit.strictEqual(new Sao.PYSON.Decoder().decode(eval_), true,
-                'decode(And([true, true]))');
+                'decode(And(true, true))');
 
         eval_ = new Sao.PYSON.Encoder().encode(
-                new Sao.PYSON.And([true, true, true]));
+                new Sao.PYSON.And(true, true, true));
         QUnit.strictEqual(new Sao.PYSON.Decoder().decode(eval_), true,
-                'decode(And([true, true, true]))');
+                'decode(And(true, true, true))');
 
         eval_ = new Sao.PYSON.Encoder().encode(
-                new Sao.PYSON.And([true, false]));
+                new Sao.PYSON.And(true, false));
         QUnit.strictEqual(new Sao.PYSON.Decoder().decode(eval_), false,
-                'decode(And([true, false]))');
+                'decode(And(true, false))');
 
         eval_ = new Sao.PYSON.Encoder().encode(
-                new Sao.PYSON.And([false, true]));
+                new Sao.PYSON.And(false, true));
         QUnit.strictEqual(new Sao.PYSON.Decoder().decode(eval_), false,
-                'decode(And([false, true]))');
+                'decode(And(false, true))');
 
         eval_ = new Sao.PYSON.Encoder().encode(
-                new Sao.PYSON.And([false, false]));
+                new Sao.PYSON.And(false, false));
         QUnit.strictEqual(new Sao.PYSON.Decoder().decode(eval_), false,
-                'decode(And([false, false]))');
+                'decode(And(false, false))');
 
         eval_ = new Sao.PYSON.Encoder().encode(
-                new Sao.PYSON.And([false, false, false]));
+                new Sao.PYSON.And(false, false, false));
         QUnit.strictEqual(new Sao.PYSON.Decoder().decode(eval_), false,
-                'decode(And([false, false, false]))');
+                'decode(And(false, false, false))');
 
         eval_ = new Sao.PYSON.Encoder().encode(
-                new Sao.PYSON.And([true, false, false]));
+                new Sao.PYSON.And(true, false, false));
         QUnit.strictEqual(new Sao.PYSON.Decoder().decode(eval_), false,
-                'decode(And([true, false, false]))');
+                'decode(And(true, false, false))');
 
         eval_ = new Sao.PYSON.Encoder().encode(
-                new Sao.PYSON.And([false, true, false]));
+                new Sao.PYSON.And(false, true, false));
         QUnit.strictEqual(new Sao.PYSON.Decoder().decode(eval_), false,
-                'decode(And([false, true, false]))');
+                'decode(And(false, true, false))');
 
         eval_ = new Sao.PYSON.Encoder().encode(
-                new Sao.PYSON.And([false, false, true]));
+                new Sao.PYSON.And(false, false, true));
         QUnit.strictEqual(new Sao.PYSON.Decoder().decode(eval_), false,
-                'decode(And([false, false, true]))');
-        QUnit.strictEqual(new Sao.PYSON.And([false, true, true]).toString(),
-                "And([false, true, true])");
+                'decode(And(false, false, true))');
+        QUnit.strictEqual(new Sao.PYSON.And(false, true, true).toString(),
+                "And(false, true, true)");
     });
 
     QUnit.test('PYSON Or', function() {
-        var value = new Sao.PYSON.Or([true, false]).pyson();
-        QUnit.strictEqual(value.__class__, 'Or', 'Or([true, false]).pyson()');
+        var value = new Sao.PYSON.Or(true, false).pyson();
+        QUnit.strictEqual(value.__class__, 'Or', 'Or(true, false).pyson()');
         QUnit.ok(Sao.common.compare(value.s, [true, false]),
-            'Or([true, false]).pyson()');
+            'Or(true, false).pyson()');
 
         QUnit.throws(function() {
-            new Sao.PYSON.Or([true]);
-        }, 'must have at least 2 statements', 'Or([true])');
-        QUnit.throws(function() {
-            new Sao.PYSON.Or([]);
-        }, 'must have at least 2 statements', 'Or([])');
+            new Sao.PYSON.Or(true);
+        }, 'must have at least 2 statements', 'Or(true)');
         QUnit.throws(function() {
             new Sao.PYSON.Or();
-        }, 'must have at least 2 statements', 'Or([])');
+        }, 'must have at least 2 statements', 'Or()');
 
-        QUnit.ok(Sao.common.compare(new Sao.PYSON.Or([true, false]).types(),
-                    ['boolean']), 'Or([true, false]).types()');
+        QUnit.ok(Sao.common.compare(new Sao.PYSON.Or(true, false).types(),
+                    ['boolean']), 'Or(true, false).types()');
 
         var eval_;
         eval_ = new Sao.PYSON.Encoder().encode(
-                new Sao.PYSON.Or([true, true]));
+                new Sao.PYSON.Or(true, true));
         QUnit.strictEqual(new Sao.PYSON.Decoder().decode(eval_), true,
-                'decode(Or([true, true]))');
+                'decode(Or(true, true))');
 
         eval_ = new Sao.PYSON.Encoder().encode(
-                new Sao.PYSON.Or([true, true, true]));
+                new Sao.PYSON.Or(true, true, true));
         QUnit.strictEqual(new Sao.PYSON.Decoder().decode(eval_), true,
-                'decode(Or([true, true, true]))');
+                'decode(Or(true, true, true))');
 
         eval_ = new Sao.PYSON.Encoder().encode(
-                new Sao.PYSON.Or([true, false]));
+                new Sao.PYSON.Or(true, false));
         QUnit.strictEqual(new Sao.PYSON.Decoder().decode(eval_), true,
-                'decode(Or([true, false]))');
+                'decode(Or(true, false))');
 
         eval_ = new Sao.PYSON.Encoder().encode(
-                new Sao.PYSON.Or([false, true]));
+                new Sao.PYSON.Or(false, true));
         QUnit.strictEqual(new Sao.PYSON.Decoder().decode(eval_), true,
-                'decode(Or([false, true]))');
+                'decode(Or(false, true))');
 
         eval_ = new Sao.PYSON.Encoder().encode(
-                new Sao.PYSON.Or([false, false]));
+                new Sao.PYSON.Or(false, false));
         QUnit.strictEqual(new Sao.PYSON.Decoder().decode(eval_), false,
-                'decode(Or([false, false]))');
+                'decode(Or(false, false))');
 
         eval_ = new Sao.PYSON.Encoder().encode(
-                new Sao.PYSON.Or([false, false, false]));
+                new Sao.PYSON.Or(false, false, false));
         QUnit.strictEqual(new Sao.PYSON.Decoder().decode(eval_), false,
-                'decode(Or([false, false, false]))');
+                'decode(Or(false, false, false))');
 
         eval_ = new Sao.PYSON.Encoder().encode(
-                new Sao.PYSON.Or([true, false, false]));
+                new Sao.PYSON.Or(true, false, false));
         QUnit.strictEqual(new Sao.PYSON.Decoder().decode(eval_), true,
-                'decode(Or([true, false, false]))');
+                'decode(Or(true, false, false))');
 
         eval_ = new Sao.PYSON.Encoder().encode(
-                new Sao.PYSON.Or([false, true, false]));
+                new Sao.PYSON.Or(false, true, false));
         QUnit.strictEqual(new Sao.PYSON.Decoder().decode(eval_), true,
-                'decode(Or([false, true, false]))');
+                'decode(Or(false, true, false))');
 
         eval_ = new Sao.PYSON.Encoder().encode(
-                new Sao.PYSON.Or([false, false, true]));
+                new Sao.PYSON.Or(false, false, true));
         QUnit.strictEqual(new Sao.PYSON.Decoder().decode(eval_), true,
-                'decode(Or([false, false, true]))');
-        QUnit.strictEqual(new Sao.PYSON.Or([false, true, true]).toString(),
-                "Or([false, true, true])");
+                'decode(Or(false, false, true))');
+        QUnit.strictEqual(new Sao.PYSON.Or(false, true, true).toString(),
+                "Or(false, true, true)");
     });
 
     QUnit.test('PYSON Equal', function() {
@@ -1233,6 +1227,11 @@
         });
     });
 
+    QUnit.test('PYSON eval', function() {
+        QUnit.strictEqual(eval_pyson('True'), true, "eval_pyson('True')");
+        QUnit.strictEqual(eval_pyson('False'), false, "eval_pyson('False')");
+    });
+
     QUnit.test('DomainParser.group_operator', function() {
         var parser = new Sao.common.DomainParser();
         QUnit.ok(Sao.common.compare(parser.group_operator(['a', '>', '=']),