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

kernpy-1.0.1.dist-info/METADATA

@@ -0,0 +1,497 @@
+Metadata-Version: 2.4
+Name: kernpy
+Version: 1.0.1
+Summary: Python Humdrum **kern and **mens utilities
+Project-URL: Homepage, https://github.com/OMR-PRAIG-UA-ES/kernpy
+Project-URL: Documentation, https://github.com/OMR-PRAIG-UA-ES/kernpy#readme
+Project-URL: Issues, https://github.com/OMR-PRAIG-UA-ES/kernpy/issues
+Author-email: David Rizo Valero <drizo@ua.es>, Joan Cerveto Serrano <joan.cerveto@ua.es>
+License: AGPL-3.0-only
+Classifier: License :: OSI Approved :: GNU Affero General Public License v3
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.9
+Requires-Dist: antlr4-python3-runtime
+Requires-Dist: pillow
+Requires-Dist: requests
+Requires-Dist: urllib3>=1.26.6
+Description-Content-Type: text/markdown
+
+# Python Humdrum **kern and **mens utilities
+
+[![License: AGPL v3](https://img.shields.io/badge/License-AGPL%20v3-blue.svg?style=for-the-badge)](https://www.gnu.org/licenses/agpl-3.0)
+![Python Version](https://img.shields.io/badge/Python-3.9+-3776AB?logo=python&logoColor=white&style=for-the-badge)
+[![PyPI](https://img.shields.io/pypi/v/kernpy?color=brightgreen&label=PyPI&style=for-the-badge&logo=pypi)](https://pypi.org/project/kernpy/)
+[![Docs](https://img.shields.io/badge/docs-available-blue?style=for-the-badge&logo=readthedocs)](https://kernpy.pages.dev)
+[![Tests](https://img.shields.io/badge/tests-passing-brightgreen?style=for-the-badge&logo=pytest)](https://github.com/kernpy/kernpy/actions)
+[![Contributions welcome](https://img.shields.io/badge/contributions-welcome-orange?style=for-the-badge&logo=github)](CONTRIBUTING.md)
+
+
+Python package that provides comprehensive tools for working with symbolic modern and mensural notations in Humdrum format. kernpy is a fully open-source project open to contributions.
+
+## Documentation 
+Visit the online website: <a target="_blank" href="https://kernpy.pages.dev/">https://kernpy.pages.dev/</a>
+
+## Index:
+- [Code examples](#code-examples)
+- [Installation](#installation)
+- [Documentation](#documentation)
+- [Run tests](#run-tests)
+- [Contributing](#contributing)
+- [Citation](#citation)
+
+
+## Code examples
+
+### Basic Usage
+
+Load a `**kern`/`**mens` file into a `kp.Document`.
+```python
+import kernpy as kp
+
+# Read a **kern file
+document, errors = kp.load("path/to/file.krn")
+```
+
+Load a `**kern`/`**mens` from a string into a `kp.Document`.
+```python
+import kernpy as kp
+
+document, errors = kp.loads("**kern\n*clefC3\n*k[b-e-a-]\n*M3/4\n4e-\n4g\n4c\n=1\n4r\n2cc;\n==\n*-")
+```
+
+Create a new standardized file from a `kp.Document`.
+```python
+import kernpy as kp
+
+kp.dump(document, "newfile.krn")
+```
+
+Save the document in a string from a `kp.Document`.
+```python
+import kernpy as kp
+
+content = kp.dumps(document)
+````
+
+### Exploring different options when creating new files
+
+Only use the specified spines in `spine_types`.
+```python
+import kernpy as kp
+
+# only export the **kern spines
+kp.dump(document, "newfile_core.krn",
+        spine_types=['**kern'])
+
+# only export the **text spines
+kp.dump(document, "newfile_lyrics.krn",
+        spine_types=['**text])
+                     
+# only export **kern and **text spines     
+kp.dump(document, "newfile_core_and_lyrics.krn",
+        spine_types=['*+text'])
+```
+
+- The categories are hierarchically defined in the `TokenCategory` class.
+See the hierarchy as a tree
+```python
+import kernpy as kp
+
+
+print(kp.TokenCategory.tree())
+```
+Tree:
+```txt
+.
+├── STRUCTURAL
+│   ├── HEADER
+│   └── SPINE_OPERATION
+├── CORE
+│   ├── NOTE_REST
+│   │   ├── DURATION
+│   │   ├── NOTE
+│   │   │   ├── PITCH
+│   │   │   ├── DECORATION
+│   │   │   └── ALTERATION
+│   │   └── REST
+│   ├── CHORD
+│   ├── EMPTY
+│   └── ERROR
+├── SIGNATURES
+│   ├── CLEF
+│   ├── TIME_SIGNATURE
+│   ├── METER_SYMBOL
+│   ├── KEY_SIGNATURE
+│   └── KEY_TOKEN
+├── ENGRAVED_SYMBOLS
+├── OTHER_CONTEXTUAL
+├── BARLINES
+├── COMMENTS
+│   ├── FIELD_COMMENTS
+│   └── LINE_COMMENTS
+├── DYNAMICS
+├── HARMONY
+├── FINGERING
+├── LYRICS
+├── INSTRUMENTS
+├── IMAGE_ANNOTATIONS
+│   ├── BOUNDING_BOXES
+│   └── LINE_BREAK
+├── OTHER
+├── MHXM
+└── ROOT
+```
+
+- Use `include` for selecting the **kern semantic categories **to use**. The output only contains what is passed. By default, all the categories are included.
+```python
+import kernpy as kp
+
+
+kp.dump(document, "newfile_only_clefs.krn",
+        include={kp.TokenCategory.CLEF})
+kp.dump(document, "newfile_only_durations_and_bounding_boxes.krn",
+        include={kp.TokenCategory.DURATION, kp.TokenCategory.BOUNDING_BOXES})
+```
+- Use `exclude` for selecting the **kern semantic categories **to not use**. The output contains everything except what is passed. By default, any category is excluded.
+```python
+import kernpy as kp
+
+kp.dump(document, "newfile_without_pitches.krn",
+        exclude={kp.TokenCategory.PITCH})
+kp.dump(document, "newfile_without_durations_or_rests.krn",
+        exclude={kp.TokenCategory.BARLINES, kp.TokenCategory.REST})
+```
+- Use `include` and `exclude` together to select the **kern semantic categories **to use**. The output combines both.
+```python
+import kernpy as kp
+
+kp.dump(document, "newfile_custom.krn",
+        include=kp.BEKERN_CATEGORIES,  # Preloaded set of simple categories
+        exclude={kp.TokenCategory.PITCH})
+
+# Inspect the BEKERN preloaded categories
+print(kp.BEKERN_CATEGORIES)
+```
+
+- Use `tokenizer` to select how the categories are split. By default, the `normalizedKern` tokenizer is used.
+
+```python
+import kernpy as kp
+
+kp.dump(document, "newfile_normalized.krn",
+        tokenizer=kp.Encoding.normalizedKern)  # Default tokenizer
+```
+Select the proper Humdrum **kern tokenizer:
+
+`kernpy` provides different tokenizers to export the content each symbol in different formats.
+
+| Encoding | Tokenized    | Description                            |
+|----------|--------------|----------------------------------------|
+| kern     | 2.bb-_L      | Traditional Humdrum **kern encoding    |
+| ekern    | 2@.@bb@-·_·L | Extended Humdrum **kern encoding       |
+
+Use the `Encoding` enum class to select the tokenizer:
+
+```python
+import kernpy as kp
+
+doc, _ = kp.load('resource_dir/legacy/chor048.krn')
+
+kern_content = kp.dumps(doc, tokenizer=kp.Encoding.normalizedKern)
+ekern_content = kp.dumps(doc, tokenizer=kp.Encoding.eKern)
+```
+
+- Use `from_measure` and `to_measure` to select the measures to export. By default, all the measures are exported.
+```python
+import kernpy as kp
+
+kp.dump(document, "newfile_1_to_10.krn",
+        from_measure=1,  # First from measure 1
+        to_measure=10)   # Last measure exported
+```
+
+- Use `spine_ids` to select the spines to export. By default, all the spines are exported.
+```python
+import kernpy as kp
+
+kp.dump(document, "newfile_1_and_2.krn",
+        spine_ids=[0, 1])  # Export only the first and the second spine
+```
+
+- Use `show_measure_numbers` to select if the measure numbers are shown. By default, the measure numbers are shown.
+```python
+import kernpy as kp
+
+kp.dump(document, "newfile_no_measure_numbers.krn",
+        show_measure_numbers=False)  # Do not show measure numbers
+```
+
+- Use all the options at the same time.
+
+```python
+import kernpy as kp
+
+kp.dump(document, "newfile.krn",
+        spine_types=['**kern'],  # Export only the **kern spines
+        include=kp.BEKERN_CATEGORIES,  # Token categories to include
+        exclude={kp.TokenCategory.PITCH},  # Token categories to exclude
+        tokenizer=kp.Encoding.eKern,  # Kern encoding
+        from_measure=1,  # First from measure 1
+        to_measure=10,  # Last measure exported
+        spine_ids=[0, 1],  # Export only the first and the second spine
+        show_measure_numbers=False,  # Do not show measure numbers
+        )
+```
+
+## Exploring `kernpy` utilities.
+
+
+- Spines analysis 
+Retrieve all the spine types of the document.
+```python
+import kernpy as kp
+
+kp.spine_types(document)
+# ['**kern', '**kern', '**kern', '**kern', '**root', '**harm']
+
+kp.spine_types(document, spine_types=None)
+# ['**kern', '**kern', '**kern', '**kern', '**root', '**harm']
+
+kp.spine_types(document, spine_types=['**kern'])
+# ['**kern', '**kern', '**kern', '**kern']
+```
+
+- Get specific **kern spines.
+```python
+import kernpy as kp
+
+def how_many_instrumental_spines(document):
+    print(kp.spine_types(document, ['**kern']))
+    return len(kp.spine_types(document, ['**kern']))
+# ['**kern', '**kern', '**kern', '**kern']
+# 4
+
+def has_voice(document):
+    return len(kp.spine_types(document, ['**text'])) > 0
+# True
+```
+
+
+
+### How many measures are there in the document? Which measures do you want to export?
+
+After reading the score into the `Document` object. You can get some useful data:
+```python
+first_measure: int = document.get_first_measure()
+last_measure: int = document.measures_count()
+```
+
+Iterate over all the measures of the document.
+```python
+import kernpy as kp
+
+doc, _ = kp.load('resource_dir/legacy/chor048.krn')  # 10 measures score
+for i in range(doc.get_first_measure(), doc.measures_count(), 1):  # from 1 to 11, step 1
+    # Export only the i-th measure (1 long measure scores)
+    content_ith_measure = kp.dumps(doc, from_measure=i, to_measure=i)
+    
+    # Export the i-th measure and the next 4 measures (5 long measure scores)
+    if i + 4 <= doc.measures_count():
+        content_longer = kp.dumps(doc, from_measure=i, to_measure=i + 4)
+    ...
+```
+
+It is easier to iterate over all the measures using the `for measure in doc`: loop
+(using the `__ iter__` method):
+```python
+import kernpy as kp
+
+for measure in doc:
+    content = kp.dumps(doc, from_measure=measure, to_measure=measure)
+    ...
+```
+
+Exploring the page bounding boxes.
+
+```python
+import kernpy as kp
+
+# Iterate over the pages using the bounding boxes
+doc, _ = kp.load('kern_having_bounding_boxes.krn')
+
+# Inspect the bounding boxes
+print(doc.page_bounding_boxes)
+
+
+def are_there_bounding_boxes(doc):
+   return len(doc.get_all_tokens(filter_by_categories=[kp.TokenCategory.BOUNDING_BOXES])) > 0
+
+
+# True
+
+# Iterate over the pages
+for page_label, bounding_box_measure in doc.page_bounding_boxes.items():
+   print(f"Page: {page_label}"
+         f"Bounding box: {bounding_box_measure}"
+         f"from_measure: {bounding_box_measure.from_measure}"
+         f"to_measure+1: {bounding_box_measure.to_measure}")  # TODO: Check bounds
+   kp.dump(doc, f"foo_{page_label}.ekrn",
+           spine_types=['**kern'],
+           token_categories=kp.BEKERN_CATEGORIES,
+           tokenizer=kp.Encoding.eKern,
+           from_measure=bounding_box_measure.from_measure,
+           to_measure=bounding_box_measure.to_measure - 1  # TODO: Check bounds            
+           )
+```
+
+### Merge different full kern scores
+```python
+import kernpy as kp
+# NOT AVAILABLE YET!!!
+# Pay attention to `kp.merge` too.
+
+# Concat two valid documents
+score_a = '**kern\n*clefG2\n=1\n4c\n4d\n4e\n4f\n*-\n'
+score_b = '**kern\n*clefG2\n=1\n4a\n4c\n4d\n4c\n*-\n'
+concatenated = kp.merge([score_a, score_b])
+```
+
+# Concatenate sorted fragments of the same score
+```python
+import kernpy as kp
+
+fragment_a = '**kern\n*clefG2\n=1\n4c\n4d\n4e\n4f\n*-\n'
+fragment_b = '=2\n4a\n4c\n4d\n4c\n*-\n=3\n4a\n4c\n4d\n4c\n*-\n'
+fragment_c = '=4\n4a\n4c\n4d\n4c\n*-\n=5\n4a\n4c\n4d\n4c\n*-\n'
+fragment_d = '=6\n4a\n4c\n4d\n4c\n*-\n=7\n4a\n4c\n4d\n4c\n*-\n==*-'
+fragments = [fragment_a, fragment_b, fragment_c, fragment_d]
+
+doc_merged, indexes = kp.concat(fragments)
+for index_pair in indexes:
+    from_measure, to_measure = index_pair
+    print(f'From measure: {from_measure}, To measure: {to_measure}')
+    print(kp.dumps(doc_merged, from_measure=from_measure, to_measure=to_measure))
+
+# Sometimes is useful having a different separator between the fragments rather than the default one (newline)...
+doc_merged, indexes = kp.concat(fragments, separator='')
+```
+
+### Inspect the `Document` class functions
+```python
+import kernpy as kp
+doc, _ = kp.load('resource_dir/legacy/chor048.krn')  # 10 measures score
+
+frequencies = doc.frequencies()  # All the token categories
+filtered_frequencies = doc.frequencies(filter_by_categories=[kp.TokenCategory.SIGNATURES])
+frequencies['*k[f#c#]']
+# {
+#   'occurrences': 4,
+#   'category': SIGNATURES,
+# }
+
+# Get all the tokens in the document
+all_tokens: [kp.Token] = doc.get_all_tokens()
+all_tokens_encodings: [str] = doc.get_all_tokens_encodings()
+
+# Get the unique tokens in the document (vocabulary)
+unique_tokens: [kp.Token] = doc.get_unique_tokens()
+unique_token_encodings: [str] = doc.get_unique_token_encodings()
+
+# Get the line comments in the document
+document.get_metacomments()
+# ['!!!COM: Coltrane', '!!!voices: 1', '!!!OPR: Blue Train']
+document.get_metacomments(KeyComment='COM')
+# ['!!!COM: Coltrane']
+document.get_metacomments(KeyComment='COM', clear=True)
+# ['Coltrane']
+document.get_metacomments(KeyComment='non_existing_key')
+# []
+```
+
+## Transpose
+- Inspect what intervals are available for transposing.
+```python
+import kernpy as kp
+
+print(kp.AVAILABLE_INTERVALS)
+```
+
+- Transpose the document to a specific interval.
+```python
+import kernpy as kp
+
+doc, err = kp.load('resource_dir/legacy/chor048.krn')  # 10 measures score
+higher_octave_doc = doc.to_transposed('octave', 'up')
+
+kp.dump(higher_octave_doc, 'higher_octave.krn')
+```
+
+### On your own
+
+- Handle the document if needed.
+```python
+import kernpy as kp
+
+# Access the document tree
+print(document.tree)
+# <kernpy.core.document.DocumentTree object at 0x7f8b3b3b3d30>
+
+# View the tree-based Document structure for debugging.
+kp.graph(document, '/tmp/graph.dot')
+# Render the graph 
+# - using Graphviz extension in your IDE
+# - in the browser here: https://dreampuf.github.io/GraphvizOnline/
+```
+
+
+## Installation
+
+### Production version:
+Just install the last version of **kernpy** using pip:
+```shell
+pip3 install kernpy
+
+# ensure you have the latest version
+pip3 install kernpy --upgrade 
+```
+
+> [!NOTE]
+> This module is downloaded by default in the _/tmp_ directory in Linux. So it is removed when shutdown the machine.
+
+<hr>
+
+## Documentation
+Documentation available at [https://kernpy.pages.dev/](https://kernpy.pages.dev/)
+
+
+**kernpy** also supports been executed as a module. Find out the available commands:
+```shell
+python -m kernpy --help
+python -m kernpy <command> <options>
+```
+
+
+## Run tests:
+```shell
+cd tests && python -m pytest
+```
+
+
+## Contributing
+
+We welcome contributions from the community! If you'd like to contribute to the project, please follow these steps:
+
+Go to the file [CONTRIBUTING.md](CONTRIBUTING.md) for more information on how to contribute.
+
+## Citation:
+```bibtex
+@inproceedings{kernpy_mec_2025,
+  title={{kernpy: a Humdrum **Kern Oriented Python Package for Optical Music Recognition Tasks}},
+  author={Cerveto-Serrano, Joan and Rizo, David and Calvo-Zaragoza, Jorge},
+  booktitle={{Proceedings of the Music Encoding Conference (MEC2025)}},
+  address={London, United Kingdom},
+  year={2025}
+}
+```
+

kernpy-1.0.1.dist-info/RECORD

@@ -0,0 +1,51 @@
+kernpy/__init__.py,sha256=HdHS0T3se8qIU0d2mULhwhgJRfgGmNA4Zhxl4YvjeVA,313
+kernpy/__main__.py,sha256=ZxsPlyfgzpZjU8TdNBc1SrMyTTr-Osu4j08DXHAgpVQ,4437
+kernpy/test_grammar.sh,sha256=MP9Hav9nPxTbHeofFEuunwDsLcBoeFRtzPp4bbPnqBU,520
+kernpy/visualize_analysis.sh,sha256=z68jyZ8zj4w7v5CoC8-J7PGh7dYA_iQbuFL5T63X6qY,526
+kernpy/core/__init__.py,sha256=gIbOKMWcPcQc4c6QpslWnAw9XkcMJ6OvedHANyDABbs,2581
+kernpy/core/_io.py,sha256=WqH30iDjfzGRCIzlqrAE9Oi_nfyleUpp8xGK8xZPh_w,1208
+kernpy/core/base_antlr_importer.py,sha256=2pPJ7sdWWCBU9Vw2ZAx-j-674DlSp82ajapeex-pF2I,1475
+kernpy/core/base_antlr_spine_parser_listener.py,sha256=HqKYACgzdiIc1fAoSaiLzfogkv7pAuiqUHlIRF8c--c,9837
+kernpy/core/basic_spine_importer.py,sha256=aYceG5wxlm7qTrd0KTR6-P4v4VVlYYPEe8omd3vmC0I,1523
+kernpy/core/document.py,sha256=Y_Wpwc-t1GkaGr2QVU0hqLRFJv9wJ_Nm6UitgwAlT8w,34892
+kernpy/core/dyn_importer.py,sha256=dKgZqVIdEELUu8HY63ClLJAMQXXItjHmaYxxOwFZRiY,1025
+kernpy/core/dynam_spine_importer.py,sha256=crg4LwsWr56VZ6GLYAO1CDnLuum9f1tlX_pXCqKemEc,1450
+kernpy/core/error_listener.py,sha256=bTlAZvVIQx_6BLZ3oRut_pn24JnV8_7GnNONiwoMMPU,1516
+kernpy/core/exporter.py,sha256=5MWOk1JmPtpXfjN_VBv5jxUhYu8hhAZwt9eB5u9f1eM,21371
+kernpy/core/fing_spine_importer.py,sha256=5GLPPakmZVRcNbbaoCn1p1cQdat5QttflbpKu3AytQU,1382
+kernpy/core/generic.py,sha256=9OTDE2t49laVk6fgtydK5yZh7SCfZwViP_dZUJlskA8,10967
+kernpy/core/gkern.py,sha256=nRYFLFJ0uOLJwio0DKxQ0YIqLixy6-qCM-eY8DNdxfM,16332
+kernpy/core/graphviz_exporter.py,sha256=lzeJ0sJoKCDYam1oLJ4pjnlf_NHBJFH0V9w0Pjic5SI,3447
+kernpy/core/harm_spine_importer.py,sha256=L2eVxW4-tMG3JCtCwLVx6En-ulSn9S90wdUoffj_U5s,1379
+kernpy/core/import_humdrum_old.py,sha256=NZTQgANQc2BCYJRbGG6AyxcGHxjyy8XXa9dz88zrnMk,35304
+kernpy/core/importer.py,sha256=Rg4vIvEl2yhMwYrN5NenhdQG4_2dNByCRvHCEBJgWI8,13684
+kernpy/core/importer_factory.py,sha256=mXYWaAMyd8q1o2hJg5m0gxpBHX-nX6KGPyWl-zjrX7o,1570
+kernpy/core/kern_spine_importer.py,sha256=9jKDTDDcH81U4Vws4x5msUDq89QzwbdEGYb6uHt-cDI,2581
+kernpy/core/mens_spine_importer.py,sha256=GGutGL3qeatIkdHZxiOJNcT5mc70acJ728xu-VVLkOU,692
+kernpy/core/mhxm_spine_importer.py,sha256=45QhuqIgXKkLMFkZYk17sdgOH8dfzK08mWE24fGZ-n4,1410
+kernpy/core/pitch_models.py,sha256=TpSt1uxGYhbhXs0viB1dNo4jiGxyCOHWseyRHTpfH-0,9730
+kernpy/core/root_spine_importer.py,sha256=w7oFbMeXakHF9OAlgKWm_HaGJoNq6u7BE_JUnvLiLnU,1893
+kernpy/core/spine_importer.py,sha256=_VoWcVGfDMhxDn-hCu18g_29Aw2c2bjLnaXuvW2Fbsc,1430
+kernpy/core/text_spine_importer.py,sha256=mz1qX2nviJs0VsGsN87jk6BVWCIE7mmB9IxEx4RdhT8,1522
+kernpy/core/tokenizers.py,sha256=dJsaCdPStruzToaYA-RyM9beJ9tQyZRjM4qKLK0d0k4,7899
+kernpy/core/tokens.py,sha256=0XhbYm6F9NDfYpP5gbrgzZL3qB_xWs74faTwAZghpyM,66515
+kernpy/core/transposer.py,sha256=EqsEy7Z3bWIXdxUTruBrg8z9sWdJ3Cd_KIzo_6ZuNNA,9352
+kernpy/core/generated/kernSpineLexer.interp,sha256=Y3_seqmHQu3czO9fHE8XtRwTrk8g4Txf0IKiMaHBqeg,28801
+kernpy/core/generated/kernSpineLexer.py,sha256=is10dvLvtJw4bA4rHRb_PA4JKTDKCKhAj9ASTNxVuFo,30170
+kernpy/core/generated/kernSpineLexer.tokens,sha256=ciGB91o4t7VM-tgSLtGB-BUFzHNocVJSUlkjNzK2lcc,2634
+kernpy/core/generated/kernSpineParser.interp,sha256=mnomJbjTpqMgQdAmYbqBUxk6s7D6OGYh2ya5r6qy8uc,41570
+kernpy/core/generated/kernSpineParser.py,sha256=j8jnx4gEiTVDJ-juys8YS8-4zHUNfBDuFC3sIBSsK90,338634
+kernpy/core/generated/kernSpineParser.tokens,sha256=ciGB91o4t7VM-tgSLtGB-BUFzHNocVJSUlkjNzK2lcc,2634
+kernpy/core/generated/kernSpineParserListener.py,sha256=fcOPxYkGbNbIw8Qk9aqYXnuTB48WWJCn_ZYxTdoFtpY,40015
+kernpy/core/generated/kernSpineParserVisitor.py,sha256=YSEdcb4kuIi-E4rAFhDKsCVu0lyPdlqrCMtQAeVDhZY,23821
+kernpy/io/__init__.py,sha256=9103cE_Ao1tu2mi4EaFni-YmnCnwtJqQqFqgeFuT7rA,147
+kernpy/io/public.py,sha256=p5f22Vse54vU3QYDBn5Z5iJXhRLrF9OTG1MYD8QhdGc,13782
+kernpy/polish_scores/__init__.py,sha256=EjILt5N5T9cKKdhWwflS_MU4TXuLhdHOYhW8txaicrI,217
+kernpy/polish_scores/download_polish_dataset.py,sha256=VqACpxDiM1yQYDs4QHHlZ87ZW2gkjl6R_bxYh5E67K4,14633
+kernpy/polish_scores/iiif.py,sha256=yITdrQbMsGmm8qag8TSousjCjS2io148Jk9xwEKa3B4,1526
+kernpy/util/__init__.py,sha256=dfW3nRSMkGQS7p7YebM271_0H8_pVw4IiDKeINs_LI8,152
+kernpy/util/helpers.py,sha256=Xbj3nWNyErdOpLHYd4uVyfwleXvmC5_FlYEhxaeTtS8,1549
+kernpy/util/store_cache.py,sha256=AA7SFCGQ6ryy-c02wbLy8gIQ2C-VdM1JSWFoWIK_KLA,1186
+kernpy-1.0.1.dist-info/METADATA,sha256=1SpNbdsg1KHO4FnR7vSeabwlsueGoA8y-4RDN-v2vZk,15096
+kernpy-1.0.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+kernpy-1.0.1.dist-info/RECORD,,

{kernpy-0.0.2.dist-info → kernpy-1.0.1.dist-info}/WHEEL

@@ -1,5 +1,4 @@
 Wheel-Version: 1.0
-Generator: setuptools (75.8.2)
+Generator: hatchling 1.27.0
 Root-Is-Purelib: true
 Tag: py3-none-any
-

kernpy/example.py

@@ -1 +0,0 @@
-kernpy='MEC 2025'

kernpy-0.0.2.dist-info/LICENSE

@@ -1,19 +0,0 @@
-Copyright (c) 2018 The Python Packaging Authority
-
-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.

kernpy-0.0.2.dist-info/METADATA

@@ -1,19 +0,0 @@
-Metadata-Version: 2.2
-Name: kernpy
-Version: 0.0.2
-Summary: A small example package
-Author-email: Example Author <author@example.com>
-License: MIT
-Project-URL: Homepage, https://github.com/pypa/sampleproject
-Project-URL: Issues, https://github.com/pypa/sampleproject/issues
-Classifier: Programming Language :: Python :: 3
-Classifier: Operating System :: OS Independent
-Requires-Python: >=3.8
-Description-Content-Type: text/markdown
-License-File: LICENSE
-
-# Example Package
-
-This is a simple example package. You can use
-[GitHub-flavored Markdown](https://guides.github.com/features/mastering-markdown/)
-to write your content.

kernpy-0.0.2.dist-info/RECORD

@@ -1,7 +0,0 @@
-kernpy/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-kernpy/example.py,sha256=NCJb_ORah5NZc_e8t2N7un7fJDlCoC65nwdJDHEq9uA,17
-kernpy-0.0.2.dist-info/LICENSE,sha256=2bm9uFabQZ3Ykb_SaSU_uUbAj2-htc6WJQmS_65qD00,1073
-kernpy-0.0.2.dist-info/METADATA,sha256=29JiQ-bagu4sl0HUI0E1GyFUyvK2zjau_Yl3Jls7_S8,625
-kernpy-0.0.2.dist-info/WHEEL,sha256=jB7zZ3N9hIM9adW7qlTAyycLYW9npaWKLRzaoVcLKcM,91
-kernpy-0.0.2.dist-info/top_level.txt,sha256=mioh6PCXgxwhchgmJSffHmPGltPeMR0vava0faosCxA,7
-kernpy-0.0.2.dist-info/RECORD,,

kernpy-0.0.2.dist-info/top_level.txt

@@ -1 +0,0 @@
-kernpy