Merge remote-tracking branch 'origin/master' into vuepress-website

Author: felix-andreas

README.md

@@ -9,6 +9,7 @@ This repository contains the
 [Specification of LatticeJSON](https://github.com/andreasfelix/latticejson/blob/master/latticejson/schema.json)
 in form of a [JSON Schema](https://json-schema.org).
 
+
 ## Example
 
 A LatticeJSON file for a FODO lattice:
@@ -36,40 +37,33 @@ A LatticeJSON file for a FODO lattice:
 [![PyPI](https://img.shields.io/pypi/v/latticejson.svg)](https://pypi.org/project/latticejson/)
 [![CI](https://github.com/andreasfelix/latticejson/workflows/CI/badge.svg)](https://github.com/andreasfelix/latticejson/actions?query=workflow%3ACI)
 
-This repository also contains a Python based commandline tool which is able validate and convert LatticeJSON
-files into other common lattice file formats.
+This repository also contains a Python based command-line tool which is able validate
+and convert LatticeJSON files into other common lattice file formats and vice versa.
 
 You can install and update it using pip or pipenv:
-
 ```sh
 pip install -U latticejson
 ```
 
-
 Validate a LatticeJSON file:
 ```sh
 latticejson validate /path/to/lattice.json
 ```
 
-Convert a LatticeJSON file into the elegant lattice format:
+Convert a elegant lattice format into the LatticeJSON format:
 ```sh
-latticejson convert elegant /path/to/lattice.json
+latticejson convert --to json /path/to/lattice.lte
 ```
 
 To activate Bash completion add
-
 ```
 eval "$(_LATTICEJSON_COMPLETE=source latticejson)"
 ```
 
 to your `.bashrc`. Or, create an activation script with:
-
-
 ```
 _LATTICEJSON_COMPLETE=source latticejson > latticejson-complete.sh
 ```
 
 ## License
 [GNU General Public License v3.0](https://github.com/andreasfelix/latticejson/blob/master/LICENSE)
-
-

latticejson/__about__.py

@@ -1,4 +1,4 @@
-__title__ = "latticeJSON"
+__title__ = "LatticeJSON"
 __description__ = "A JSON based lattice file format"
 __url__ = "https://github.com/andreasfelix/latticejson"
 __version__ = "0.0.2"

latticejson/__init__.py

@@ -1,4 +1,5 @@
 from .io import read, convert
 from .validate import validate
 from .convert import elegant_to_latticejson, latticejson_to_elegant
-from .exceptions import UndefinedObjectError
+from .migrate import migrate
+from .exceptions import UndefinedObjectError, UndefinedRPNVariableError

latticejson/cli.py

@@ -1,10 +1,17 @@
 import click
 import json
 from pathlib import Path
+import itertools
 
 from .validate import validate_file
-from .io import convert_file
+from .io import convert as _convert
 from .parse import parse_elegant as _parse_elegant
+from .format import CompactJSONEncoder
+from .migrate import migrate as _migrate
+
+
+FORMATS = "json", "lte"
+dump_latticejson = lambda obj: json.dumps(obj, cls=CompactJSONEncoder, indent=4)
 
 
 @click.group()
@@ -14,32 +21,73 @@ def main():
 
 
 @main.command()
-@click.argument("output_format")
 @click.argument("file", type=click.Path(exists=True))
-def convert(**kwargs):
-    """Convert a latticeJSON or elegant file into another format."""
-    output_format = kwargs["output_format"].lower()
-    if output_format in ("latticejson", "lj", "json"):
-        output_format = "latticejson"
-    elif output_format in ("elegant", "ele", "lte"):
-        output_format = "elegant"
-    else:
-        raise Exception(f"Unknown format {output_format}")
+@click.option(
+    "--from",
+    "from_",
+    type=click.Choice(FORMATS, case_sensitive=False),
+    help="Source format [optional, default: use file extension]",
+)
+@click.option(
+    "--to",
+    required=True,
+    type=click.Choice(FORMATS, case_sensitive=False),
+    help="Destination format",
+)
+def convert(file, from_, to):
+    """Convert a LatticeJSON or elegant file into another format."""
+    path = Path(file)
+    if from_ is None:
+        from_ = path.suffix[1:]
 
-    res = convert_file(kwargs["file"], output_format)
-    print(res)
+    click.echo(_convert(path.read_text(), from_, to))
 
 
 @main.command()
 @click.argument("file", type=click.Path(exists=True))
-def validate(**kwargs):
-    """Validate a latticeJSON lattice file."""
-    validate_file(kwargs["file"])
+def validate(file):
+    """Validate a LatticeJSON lattice file."""
+    validate_file(file)
+
+
+@main.command()
+@click.argument("file", type=click.Path(exists=True))
+def parse_elegant(file):
+    """Parse elegant file but do not convert to LatticeJSON."""
+    text = Path(file).read_text()
+    click.echo(dump_latticejson(_parse_elegant(text)))
+
+
+@main.command()
+@click.argument("files", nargs=-1, type=click.Path(exists=True))
+@click.option(
+    "--dry-run",
+    "-d",
+    is_flag=True,
+    help="Don't write the files back, just output the formatted files.",
+)
+def autoformat(files, dry_run):
+    """Format a LatticeJSON file."""
+    for path in itertools.chain.from_iterable(
+        path.rglob("*.json") if path.is_dir() else (path,) for path in map(Path, files)
+    ):
+        latticejson = json.loads(path.read_text())
+        formatted = dump_latticejson(latticejson)
+        click.secho(f"reformatted {path}", bold=True)
+        if dry_run:
+            click.echo(formatted)
+        else:
+            path.write_text(formatted)
 
 
 @main.command()
 @click.argument("file", type=click.Path(exists=True))
-def parse_elegant(**kwargs):
-    """Parse elegant file but do not convert to latticeJSON."""
-    text = Path(kwargs["file"]).read_text()
-    print(json.dumps(_parse_elegant(text), indent=4))
+@click.option("--from", "from_", required=True, help="Initial version")
+@click.option("--to", required=True, help="Final version")
+def migrate(file, from_, to):
+    """Migrate old LatticeJSON files to newer versions."""
+    text = Path(file).read_text()
+    initial_version = from_.split(".")
+    final_version = to.split(".")
+    latticejson = _migrate(json.loads(text), initial_version, final_version)
+    click.echo(dump_latticejson(latticejson))

latticejson/convert.py

@@ -25,8 +25,8 @@
 
 
 def latticejson_to_elegant(lattice_dict) -> str:
-    """Convert latticeJSON dict to elegant lattice file format.
-    :param dict: dict in latticeJSON format
+    """Convert LatticeJSON dict to elegant lattice file format.
+    :param dict: dict in LatticeJSON format
     :return: string with in elegant lattice file format
     """
     elements = lattice_dict["elements"]
@@ -50,14 +50,14 @@ def latticejson_to_elegant(lattice_dict) -> str:
 
 
 def elegant_to_latticejson(string):
-    """Convert an elegant lattice file to a latticeJSON dict.
+    """Convert an elegant lattice file to a LatticeJSON dict.
 
     :param str string: input lattice file as string
     :param lattice_name: name of the lattice
     :type str, optional
     :param description: description of the lattice
     :type str, optional
-    :return: dict in latticeJSON format
+    :return: dict in LatticeJSON format
     """
     elegant_dict = parse_elegant(string)
 

latticejson/format.py

@@ -0,0 +1,18 @@
+import json
+
+
+class CompactJSONEncoder(json.JSONEncoder):
+    """A JSON Encoder which only indents the first two levels."""
+
+    def encode(self, obj, level=0):
+        if isinstance(obj, dict) and level < 2:
+            items_indent = (level + 1) * self.indent * " "
+            items_string = ",\n".join(
+                f"{items_indent}{json.dumps(key)}: {self.encode(value, level=level+1)}"
+                for key, value in obj.items()
+            )
+            dict_indent = level * self.indent * " "
+            newline = "\n" if level == 0 else ""
+            return f"{{\n{items_string}\n{dict_indent}}}{newline}"
+        else:
+            return json.dumps(obj)

latticejson/io.py

@@ -6,31 +6,18 @@
 
 
 def read(text, file_format) -> Dict:
-    """Read/validate lattice file and return latticeJSON dict."""
-
-    if file_format == ".json":
+    """Read/validate lattice file and return LatticeJSON dict."""
+    if file_format == "json":
         latticejson = json.loads(text)
-    elif file_format == ".lte":
+    elif file_format == "lte":
         latticejson = elegant_to_latticejson(text)
     else:
         raise NotImplementedError(f"Unkown file file_format {file_format}.")
 
-    # validate(latticejson)
+    validate(latticejson)
     return latticejson
 
 
-def read_file(path) -> Dict:
-    """Read lattice file from path
-
-    :param path path-like: Path to lattice file
-    :return: latticeJSON compliant dict.
-    """
-    path = Path(path)
-    suffix = path.suffix
-    text = path.read_text()
-    return read(text, suffix)
-
-
 def convert(text, input_format, output_format) -> str:
     """Convert lattice file to format.
 
@@ -42,23 +29,8 @@ def convert(text, input_format, output_format) -> str:
     :rtype: str
     """
     lattice_json = read(text, input_format)
-    if output_format == "latticejson":
+    if output_format == "json":
         return json.dumps(lattice_json, indent=4)
-    elif output_format == "elegant":
+    elif output_format == "lte":
         return latticejson_to_elegant(lattice_json)
-
     raise NotImplementedError(f"Converting to {output_format} is not implemented!")
-
-
-def convert_file(path, output_format) -> str:
-    """Convert a lattice file into `output_format`
-
-    :param path path-like: Path to lattice file
-    :param output_format str: Format of the new lattice file
-    :return: Returns the new lattice file as string
-    :rtype: str
-    """
-    path = Path(path)
-    suffix = path.suffix
-    text = path.read_text()
-    return convert(text, suffix, output_format)

latticejson/migrate.py

@@ -0,0 +1,24 @@
+import sys
+
+
+def migrate(initial: dict, initial_version: tuple, final_version: tuple):
+    function = getattr(
+        sys.modules[__name__],
+        f"migrate_{'_'.join(initial_version)}_to_{'_'.join(final_version)}",
+        None,
+    )
+    if function is None:
+        raise NotImplementedError(f"Unkown versions {initial_version}, {final_version}")
+
+    return function(initial)
+
+
+def migrate_0_0_2_to_0_0_3(initial: dict):
+    final = initial.copy()
+    elements_final = {}
+    for name, attributes in final["elements"].items():
+        type_ = attributes.pop("type")
+        elements_final[name] = type_, attributes
+
+    final["elements"] = elements_final
+    return final

latticejson/rpn.lark

@@ -1,9 +1,15 @@
-%ignore /[ \t\f]/+       // ingore whitespace
+%ignore /[ \t\f]/+  // ingore whitespace
 
-int: /[+-]?\d+/
-float: /[+-]?\d+\.\d*([eE][+-]?\d+)?/ // needed to parse 1.
-     | /[+-]?\d*\.\d+([eE][+-]?\d+)?/ // needed to parse .1
-     | /[+-]?\d+[eE][+-]?\d+/         // needed to parse 1e1
+INT         :  ["+" | "-"] DIGIT_PART
+FLOAT       :  ["+" | "-"] (EXP_FLOAT | POINT_FLOAT)
+EXP_FLOAT   :  (DIGIT_PART | POINT_FLOAT) EXPONENT
+POINT_FLOAT :  [DIGIT_PART] FRACTION | DIGIT_PART "."
+DIGIT_PART  :  /\d+/
+FRACTION    :  "." DIGIT_PART
+EXPONENT    :  ("e" | "E") ["+" | "-"] DIGIT_PART
+
+int         : INT
+float       : FLOAT
 ?number: int | float
 word: /\w+/
 

latticejson/schema.json

@@ -69,6 +69,7 @@
       }
     },
     "Element": {
+      "description": "Abstract base for all elements",
       "type": "array",
       "items": [
         {
@@ -80,13 +81,9 @@
             "length"
           ],
           "properties": {
-            "type": {
-              "type": "string",
-              "description": "Type of the element."
-            },
             "description": {
               "type": "string",
-              "description": "Description of the element."
+              "description": "Optional description of the element."
             },
             "length": {
               "type": "number",