kernpy 0.0.2__py3-none-any.whl → 1.0.1__py3-none-any.whl

kernpy/__init__.py

@@ -0,0 +1,30 @@
+"""
+# kernpy
+
+=====
+
+
+Python Humdrum **kern and **mens utilities package.
+
+
+
+Execute the following command to run **kernpy** as a module:
+```shell
+python -m kernpy --help
+python -m kernpy <command> <options>
+```
+"""
+
+
+from .core import *
+
+from .io import *
+
+from .util import *
+
+from .polish_scores import *
+
+
+
+
+

kernpy/__main__.py

@@ -0,0 +1,127 @@
+"""
+This module contains the main function for the kernpy package.
+
+Usage:
+    python -m kernpy
+"""
+
+import argparse
+import sys
+from pathlib import Path
+
+from kernpy import polish_scores, ekern_to_krn, kern_to_ekern
+
+
+def create_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(description="kernpy CLI tool")
+
+    parser.add_argument('--verbose', type=int, default=1, help='Verbosity level')
+
+    group = parser.add_mutually_exclusive_group(required=True)
+    group.add_argument('--ekern2kern', action='store_true', help='Convert files from ekern to kern')
+    group.add_argument('--kern2ekern', action='store_true', help='Convert files from kern to ekern')
+    group.add_argument('--polish', action='store_true', help='Run Polish Exporter')
+    group.add_argument('--generate_fragments', action='store_true', help='Generate Fragments')
+
+    parser.add_argument('--input_path', type=str, help='Input file or directory')
+    parser.add_argument('--output_path', type=str, help='Output file or directory')
+    parser.add_argument('-r', '--recursive', action='store_true', help='Enable recursive directory processing')
+
+    # Polish Exporter
+    parser.add_argument('--input_directory', type=str, help='Polish: Input directory')
+    parser.add_argument('--output_directory', type=str, help='Polish: Output directory')
+    parser.add_argument('--instrument', type=str, help='Polish: Instrument name')
+    parser.add_argument('--kern_type', type=str, help='Polish: "krn" or "ekrn"')
+    parser.add_argument('--kern_spines_filter', type=str, help='Polish: Filter for number of kern spines')
+    parser.add_argument('--remove_empty_dirs', action='store_true', help='Polish: Remove empty directories')
+
+
+    return parser
+
+
+def find_files(directory: Path, patterns: list[str], recursive: bool = False) -> list[Path]:
+    files = []
+    for pattern in patterns:
+        if recursive:
+            files.extend(directory.rglob(pattern))
+        else:
+            files.extend(directory.glob(pattern))
+    return files
+
+
+def handle_ekern2kern(args):
+    input_path = Path(args.input_path)
+    output_path = Path(args.output_path) if args.output_path else None
+
+    if input_path.is_file():
+        out = output_path or input_path.with_suffix(".krn")
+        ekern_to_krn(str(input_path), str(out))
+        if args.verbose:
+            print(f"Converted: {input_path} → {out}")
+        return
+
+    files = find_files(input_path, ["*.ekrn", "*.ekern"], recursive=args.recursive)
+    for file in files:
+        out = file.with_suffix(".krn")
+        try:
+            ekern_to_krn(str(file), str(out))
+            if args.verbose:
+                print(f"Converted: {file} → {out}")
+        except Exception as e:
+            print(f"Error converting {file}: {e}", file=sys.stderr)
+
+
+def handle_kern2ekern(args):
+    input_path = Path(args.input_path)
+    output_path = Path(args.output_path) if args.output_path else None
+
+    if input_path.is_file():
+        out = output_path or input_path.with_suffix(".ekrn")
+        kern_to_ekern(str(input_path), str(out))
+        if args.verbose:
+            print(f"Converted: {input_path} → {out}")
+        return
+
+    files = find_files(input_path, ["*.krn", "*.kern"], recursive=args.recursive)
+    for file in files:
+        out = file.with_suffix(".ekrn")
+        try:
+            kern_to_ekern(str(file), str(out))
+            if args.verbose:
+                print(f"Converted: {file} → {out}")
+        except Exception as e:
+            print(f"Error converting {file}: {e}", file=sys.stderr)
+
+
+def handle_polish_exporter(args):
+    if args.verbose:
+        print(f"Running Polish Exporter on {args.input_directory} → {args.output_directory}")
+
+    polish_scores.download_polish_dataset.main(
+        input_directory=args.input_directory,
+        output_directory=args.output_directory,
+        kern_spines_filter=args.kern_spines_filter,
+        exporter_kern_type=args.kern_type,
+        remove_empty_directories=args.remove_empty_dirs,
+    )
+
+
+def main():
+    parser = create_parser()
+    args = parser.parse_args()
+
+    if args.verbose > 2:
+        print("Arguments:")
+        for key, val in vars(args).items():
+            print(f"  {key}: {val}")
+
+    if args.ekern2kern:
+        handle_ekern2kern(args)
+    elif args.kern2ekern:
+        handle_kern2ekern(args)
+    elif args.polish:
+        handle_polish_exporter(args)
+
+
+if __name__ == "__main__":
+    main()

kernpy/core/__init__.py

@@ -0,0 +1,119 @@
+"""
+kernpy.core
+
+=====
+
+This module contains the core functionality of the `kernpy` package.
+"""
+
+from .tokens import *
+from .document import *
+from .importer import *
+from .exporter import *
+from .graphviz_exporter import  *
+from .importer_factory import *
+from .dyn_importer import *
+from .dynam_spine_importer import *
+from .fing_spine_importer import *
+from .harm_spine_importer import *
+from .kern_spine_importer import *
+from .mens_spine_importer import *
+from .root_spine_importer import *
+from .text_spine_importer import *
+from .mhxm_spine_importer import *
+from .basic_spine_importer import *
+from .generic import *
+from .tokenizers import *
+from .transposer import *
+from .pitch_models import *
+from .gkern import *
+
+
+__all__ = [
+    'Document',
+    'TokenCategory',
+    'Importer',
+    'ExportOptions',
+    'Exporter',
+    'Encoding',
+    'GraphvizExporter',
+    'ekern_to_krn',
+    'kern_to_ekern',
+    'get_kern_from_ekern',
+    'Encoding',
+    'Tokenizer',
+    'KernTokenizer',
+    'EkernTokenizer',
+    'BekernTokenizer',
+    'BkernTokenizer',
+    'TokenizerFactory',
+    'Token',
+    'KernTokenizer',
+    'BEKERN_CATEGORIES',
+    'DynSpineImporter',
+    'DynamSpineImporter',
+    'FingSpineImporter',
+    'HarmSpineImporter',
+    'KernSpineImporter',
+    'MensSpineImporter',
+    'RootSpineImporter',
+    'TextSpineImporter',
+    'MxhmSpineImporter',
+    'BasicSpineImporter',
+    'SpineOperationToken',
+    'PitchRest',
+    'Duration',
+    'DurationClassical',
+    'DurationMensural',
+    'read',
+    'create',
+    'export',
+    'store',
+    'store_graph',
+    'transposer',
+    'get_spine_types',
+    'createImporter',
+    'TokenCategoryHierarchyMapper',
+    'TOKEN_SEPARATOR',
+    'DECORATION_SEPARATOR',
+    'Subtoken',
+    'AbstractToken',
+    'SimpleToken',
+    'ComplexToken',
+    'CompoundToken',
+    'NoteRestToken',
+    'HeaderToken',
+    'HeaderTokenGenerator',
+    'NotationEncoding',
+    'AgnosticPitch',
+    'PitchExporter',
+    'PitchExporterFactory',
+    'HumdrumPitchExporter',
+    'AmericanPitchExporter',
+    'PitchImporter',
+    'PitchImporterFactory',
+    'HumdrumPitchImporter',
+    'AmericanPitchImporter',
+    'Direction',
+    'Intervals',
+    'IntervalsByName',
+    'transpose',
+    'transpose_agnostics',
+    'transpose_encoding_to_agnostic',
+    'transpose_agnostic_to_encoding',
+    'PositionInStaff',
+    'distance',
+    'agnostic_distance',
+    'PitchPositionReferenceSystem',
+    'Clef',
+    'GClef',
+    'F3Clef',
+    'F4Clef',
+    'C1Clef',
+    'C2Clef',
+    'C3Clef',
+    'C4Clef',
+    'ClefFactory',
+    'AVAILABLE_INTERVALS'
+]
+

kernpy/core/_io.py

@@ -0,0 +1,48 @@
+from __future__ import annotations
+
+import os
+from pathlib import Path
+from typing import Optional, Union
+
+
+def _write(path: Union[str, Path], content: str) -> None:
+    """
+    Store content in a file.
+
+    Args:
+        path (str): Path to the file.
+        content (str): Content to be stored in the file.
+
+    Returns: None
+
+    """
+    if not os.path.exists(os.path.dirname(Path(path).absolute())):
+        os.makedirs(os.path.dirname(path), exist_ok=True)
+
+    with open(path, 'w+') as f:
+        f.write(content)
+
+
+def find_all_files(
+        path: Path,
+        extension: Optional[str] = None) -> list:
+    """
+    Find all files with the given extension in the given directory.
+    Args:
+        path (str): Path to the directory where the files are located.
+        extension (Optional[str]): Extension of the files to be found. If None, all files are returned.
+
+    Returns (List[str]): List of paths to the found files.
+
+    Examples:
+        >>> find_all_files('/kern_files', 'krn')
+        ...
+
+        >>> find_all_files('/files' )
+        ...
+    """
+    p = Path(path)
+    if extension is None:
+        return list(p.glob('**/*'))
+    else:
+        return list(p.glob(f'**/*.{extension}'))

kernpy/core/base_antlr_importer.py

@@ -0,0 +1,61 @@
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+
+from antlr4 import CommonTokenStream, ParseTreeWalker
+from antlr4.InputStream import InputStream
+
+
+class BaseANTLRImporter(ABC):
+    def __init__(self, input_string):
+        char_stream = InputStream(input_string)
+        self.lexer = self.createLexer(char_stream)
+        token_stream = CommonTokenStream(self.lexer)
+        self.parser = self.createParser(token_stream)
+
+    @abstractmethod
+    def createLexer(self, charStream):
+        pass
+
+    @abstractmethod
+    def createParser(self, tokenStream):
+        pass
+
+    @abstractmethod
+    def startRule(self):
+        pass
+
+
+class BaseANTLRListenerImporter(BaseANTLRImporter):
+    def __init__(self, input_string):
+        super().__init__(input_string)
+        self.listener = self.createListener()
+
+    def start(self):
+        tree = self.startRule()
+        walker = ParseTreeWalker()
+        walker.walk(self.listener, tree)
+        #ParseTreeWalker.DEFAULT.walk(walker, tree)
+
+    @abstractmethod
+    def createListener(self):
+        pass
+
+
+class BaseANTLRVisitorImporter(BaseANTLRImporter):
+    def __init__(self, input):
+        super().__init__(input)
+        self.visitor = self.createVisitor()
+
+    def start(self):
+        tree_context = self.startRule()
+        self.visitStart(tree_context)
+
+    @abstractmethod
+    def createVisitor(self):
+        pass
+
+    @abstractmethod
+    def visitStart(self, start_context):
+        pass
+

kernpy/core/base_antlr_spine_parser_listener.py

@@ -0,0 +1,196 @@
+from .generated.kernSpineParserListener import kernSpineParserListener
+from .generated.kernSpineParser import kernSpineParser
+from .tokens import BarToken, SimpleToken, TokenCategory, Subtoken, ChordToken, BoundingBox, \
+    BoundingBoxToken, ClefToken, KeySignatureToken, TimeSignatureToken, MeterSymbolToken, BarToken, NoteRestToken, \
+    KeyToken, InstrumentToken
+
+from typing import List
+
+
+class BaseANTLRSpineParserListener(kernSpineParserListener):
+    def __init__(self):
+        self.token = None
+
+        self.first_chord_element = None
+        self.chord_tokens = None
+        self.duration_subtokens = []
+        self.diatonic_pitch_and_octave_subtoken = None
+        self.accidental_subtoken = None
+        # self.decorations = {}  # in order to standardize the order of decorators, we map the different properties to their class names
+        # We cannot order it using the class name because there are rules with subrules, such as ties, or articulations. We order it using the encoding itself
+        self.decorations: List[Subtoken] = []
+        self.in_chord = False
+        # self.page_start_rows = [] # TODO
+        self.measure_start_rows = []
+        self.last_bounding_box = None
+
+    def enterStart(self, ctx: kernSpineParser.StartContext):
+        self.token = None
+        self.duration_subtokens = []
+        self.diatonic_pitch_and_octave_subtoken = None
+        self.accidental_subtoken = None
+        # self.decorations = {}
+        self.decorations = []
+
+    # def process_decorations(self, ctx: ParserRuleContext):
+    #     # in order to standardize the order of note decorators, we map the different properties to their class names
+    #     decorations = {}
+    #
+    #     for child in ctx.getChildren():
+    #         # all decorations have just a child
+    #         if child.getChildCount() != 1:
+    #             raise Exception('Only 1 decoration child expected, and found ' + child.getChildCount() + ', check '
+    #                                                                                                      'the '
+    #                                                                                                      'grammar')
+    #         clazz = type(child.getChild(0))
+    #         decoration_type = clazz.__name__
+    #         if decoration_type in decorations:
+    #             logging.warning(
+    #                 f'The decoration {decoration_type} is duplicated')  # TODO Dar información de línea, columna - ¿lanzamos excepción? - hay algunas que sí pueden estar duplicadas? Barrados?
+    #         decorations[decoration_type] = child.getText()
+    #     for key in sorted(decorations.keys()):
+    #         subtoken = Subtoken(decorations[key], TokenCategory.DECORATION)
+    #         self.duration_subtoken.append(subtoken)
+
+    def exitDuration(self, ctx: kernSpineParser.DurationContext):
+        self.duration_subtokens = [Subtoken(ctx.modernDuration().getText(), TokenCategory.DURATION)]
+        for i in range(len(ctx.augmentationDot())):
+            self.duration_subtokens.append(Subtoken(".", TokenCategory.DURATION))
+
+        if ctx.graceNote():
+            self.duration_subtokens.append(Subtoken(ctx.graceNote().getText(), TokenCategory.DURATION))
+
+        if ctx.appoggiatura():
+            self.duration_subtokens.append(Subtoken(ctx.appoggiatura().getText(), TokenCategory.DURATION))
+
+    def exitDiatonicPitchAndOctave(self, ctx: kernSpineParser.DiatonicPitchAndOctaveContext):
+        self.diatonic_pitch_and_octave_subtoken = Subtoken(ctx.getText(), TokenCategory.PITCH)
+
+    def exitNoteDecoration(self, ctx: kernSpineParser.NoteDecorationContext):
+        # clazz = type(ctx.getChild(0))
+        # decoration_type = clazz.__name__
+        # if decoration_type in self.decorations:
+        #    logging.warning(
+        #        f'The decoration {decoration_type} is duplicated after reading {ctx.getText()}')  # TODO Dar información de línea, columna - ¿lanzamos excepción? - hay algunas que sí pueden estar duplicadas? Barrados?
+
+        # self.decorations[decoration_type] = ctx.getText()
+        # We cannot order it using the class name because there are rules with subrules, such as ties, or articulations. We order it using the encoding itself. NOT YET!
+        decoration_encoding = ctx.getText()
+        decoration_subtoken = Subtoken(decoration_encoding, TokenCategory.DECORATION)
+        self.decorations.append(decoration_subtoken)
+
+    def exitRestDecoration(self, ctx: kernSpineParser.NoteDecorationContext):
+        # clazz = type(ctx.getChild(0))
+        # decoration_type = clazz.__name__
+        # if decoration_type in self.decorations:
+        #    logging.warning(
+        #        f'The decoration {decoration_type} is duplicated after reading {ctx.getText()}')  # TODO Dar información de línea, columna - ¿lanzamos excepción? - hay algunas que sí pueden estar duplicadas? Barrados?
+
+        # self.decorations[decoration_type] = ctx.getText()
+        # We cannot order it using the class name because there are rules with subrules, such as ties, or articulations. We order it using the encoding itself
+        decoration = ctx.getText();
+        if decoration != '/' and decoration != '\\':
+            decoration_encoding = ctx.getText()
+            decoration_subtoken = Subtoken(decoration_encoding, TokenCategory.DECORATION)
+            self.decorations.append(decoration_subtoken)
+
+    def addNoteRest(self, ctx, pitchduration_subtokens):
+        # subtoken = Subtoken(self.decorations[key], TokenCategory.DECORATION)
+        token = NoteRestToken(ctx.getText(), pitchduration_subtokens, self.decorations)
+        if self.in_chord:
+            self.chord_tokens.append(token)
+        else:
+            self.token = token
+
+    def exitNote(self, ctx: kernSpineParser.NoteContext):
+        pitch_duration_tokens = []
+        for duration_subtoken in self.duration_subtokens:
+            pitch_duration_tokens.append(duration_subtoken)
+        pitch_duration_tokens.append(self.diatonic_pitch_and_octave_subtoken)
+        if ctx.alteration():
+            pitch_duration_tokens.append(Subtoken(ctx.alteration().getText(), TokenCategory.ALTERATION))
+
+        self.addNoteRest(ctx, pitch_duration_tokens)
+
+    def exitRest(self, ctx: kernSpineParser.RestContext):
+        pitch_duration_tokens = []
+        for duration_subtoken in self.duration_subtokens:
+            pitch_duration_tokens.append(duration_subtoken)
+        pitch_duration_tokens.append(Subtoken('r', TokenCategory.PITCH))
+        self.addNoteRest(ctx, pitch_duration_tokens)
+
+    def enterChord(self, ctx: kernSpineParser.ChordContext):
+        self.in_chord = True
+        self.chord_tokens = []
+
+    def exitChord(self, ctx: kernSpineParser.ChordContext):
+        self.in_chord = False
+        self.token = ChordToken(ctx.getText(), TokenCategory.CHORD, self.chord_tokens)
+
+    def exitEmpty(self, ctx: kernSpineParser.EmptyContext):
+        self.token = SimpleToken(ctx.getText(), TokenCategory.EMPTY)
+
+    def exitNonVisualTandemInterpretation(self, ctx: kernSpineParser.NonVisualTandemInterpretationContext):
+        self.token = SimpleToken(ctx.getText(), TokenCategory.OTHER)
+
+    def exitVisualTandemInterpretation(self, ctx: kernSpineParser.VisualTandemInterpretationContext):
+        self.token = SimpleToken(ctx.getText(), TokenCategory.ENGRAVED_SYMBOLS)
+
+    def exitOtherContextual(self, ctx: kernSpineParser.ContextualContext):
+        self.token = SimpleToken(ctx.getText(), TokenCategory.OTHER_CONTEXTUAL)
+
+    def exitClef(self, ctx: kernSpineParser.ClefContext):
+        self.token = ClefToken(ctx.getText())
+
+    def exitKeySignature(self, ctx: kernSpineParser.KeySignatureContext):
+        self.token = KeySignatureToken(ctx.getText())
+
+    def exitKeyCancel(self, ctx: kernSpineParser.KeyCancelContext):
+        self.token = KeySignatureToken(ctx.getText())
+
+    def exitKey(self, ctx: kernSpineParser.KeyContext):
+        self.token = KeyToken(ctx.getText())
+
+    def exitTimeSignature(self, ctx: kernSpineParser.TimeSignatureContext):
+        self.token = TimeSignatureToken(ctx.getText())
+
+    def exitMeterSymbol(self, ctx: kernSpineParser.MeterSymbolContext):
+        self.token = MeterSymbolToken(ctx.getText())
+
+    def exitStructural(self, ctx: kernSpineParser.StructuralContext):
+        self.token = SimpleToken(ctx.getText(), TokenCategory.STRUCTURAL)
+
+    def exitXywh(self, ctx: kernSpineParser.XywhContext):
+        self.last_bounding_box = BoundingBox(int(ctx.x().getText()), int(ctx.y().getText()), int(ctx.w().getText()),
+                                             int(ctx.h().getText()))
+
+    def exitBoundingBox(self, ctx: kernSpineParser.BoundingBoxContext):
+        page = ctx.pageNumber().getText()
+        bbox = BoundingBox(int(ctx.xywh().x().getText()), int(ctx.xywh().y().getText()), int(ctx.xywh().w().getText()),
+                           int(ctx.xywh().h().getText()))
+        self.token = BoundingBoxToken(ctx.getText(), page, bbox)
+
+    def exitInstrument(self, ctx: kernSpineParser.InstrumentContext):
+        self.token = InstrumentToken(ctx.getText())
+
+
+    def exitBarline(self, ctx: kernSpineParser.BarlineContext):
+        txt_without_number = ''
+        if ctx.EQUAL(0) and ctx.EQUAL(1):
+            txt_without_number = '=='
+        elif ctx.EQUAL(0):
+            txt_without_number = '='
+        if ctx.barLineType():
+            txt_without_number += ctx.barLineType().getText()
+        if ctx.fermata():
+            txt_without_number += ctx.fermata().getText()
+
+        # correct wrong encodings
+        if txt_without_number == ':!:':
+            txt_without_number = ':|!|:'
+        elif txt_without_number == ':|!|:':
+            txt_without_number = ':|!|:'
+
+        self.token = BarToken(txt_without_number)
+        self.token.hidden = "-" in ctx.getText()  # hidden
+

kernpy/core/basic_spine_importer.py

@@ -0,0 +1,43 @@
+from __future__ import annotations
+from typing import Optional
+
+from .base_antlr_spine_parser_listener import BaseANTLRSpineParserListener
+from .spine_importer import SpineImporter
+from .spine_importer import SpineImporter
+from .kern_spine_importer import KernSpineImporter, KernSpineListener
+from .tokens import SimpleToken, TokenCategory, Token
+
+
+class BasicSpineImporter(SpineImporter):
+    def __init__(self, verbose: Optional[bool] = False):
+        """
+        KernSpineImporter constructor.
+
+        Args:
+            verbose (Optional[bool]): Level of verbosity for error messages.
+        """
+        super().__init__(verbose=verbose)
+
+    def import_listener(self) -> BaseANTLRSpineParserListener:
+        return KernSpineListener()  # TODO: Create a custom functional listener for BasicSpineImporter
+
+    def import_token(self, encoding: str) -> Token:
+        self._raise_error_if_wrong_input(encoding)
+
+        kern_spine_importer = KernSpineImporter()
+        token = kern_spine_importer.import_token(encoding)
+
+        ACCEPTED_CATEGORIES = {
+            TokenCategory.STRUCTURAL,
+            TokenCategory.SIGNATURES,
+            TokenCategory.EMPTY,
+            TokenCategory.BARLINES,
+            TokenCategory.IMAGE_ANNOTATIONS,
+            TokenCategory.BARLINES,
+            TokenCategory.COMMENTS,
+        }
+
+        if not any(TokenCategory.is_child(child=token.category, parent=cat) for cat in ACCEPTED_CATEGORIES):
+            return SimpleToken(encoding, TokenCategory.OTHER)
+
+        return token