jjinx 0.0.1__py3-none-any.whl

jinx/word_formation.py

@@ -0,0 +1,229 @@
+"""Word Formation.
+
+Given a sentence (a string of characters), form a list of its constituent words.
+
+Based on the description from 'An Implementation of J': https://www.jsoftware.com/ioj/iojSent.htm
+
+See also: https://code.jsoftware.com/wiki/Vocabulary/Words#WordFormation
+
+The terse naming of states and character classes has been preserved here for the sake of consistency
+with the source descriptions (except '9' is now 'NUMERIC').
+
+"""
+
+from enum import Enum
+from typing import Mapping
+
+from jinx.vocabulary import Word
+
+
+class State(Enum):
+    S = "space"
+    X = "other"
+    A = "alphanumeric"
+    N = "N"
+    NB = "NB"
+    NUMERIC = "numeric"
+    Q = "quote"
+    QQ = "even quotes"
+    Z = "trailing comment"
+
+
+class CharacterClass(Enum):
+    S = "space"
+    X = "other"
+    A = "letters excl. NB"
+    N = "N"
+    B = "B"
+    NUMERIC = "digits and _"
+    D = "."
+    C = ":"
+    Q = "'"
+
+
+class Action(Enum):
+    I = "emit, update"  # noqa: E741
+    N = "no emit, update"
+    X = "no action"
+
+
+STATE_TRANSITION: Mapping[tuple[State, CharacterClass], tuple[State, Action]] = {
+    # "space"
+    (State.S, CharacterClass.X): (State.X, Action.N),
+    (State.S, CharacterClass.S): (State.S, Action.X),
+    (State.S, CharacterClass.A): (State.A, Action.N),
+    (State.S, CharacterClass.N): (State.N, Action.N),
+    (State.S, CharacterClass.B): (State.A, Action.N),
+    (State.S, CharacterClass.NUMERIC): (State.NUMERIC, Action.N),
+    (State.S, CharacterClass.D): (State.X, Action.N),
+    (State.S, CharacterClass.C): (State.X, Action.N),
+    (State.S, CharacterClass.Q): (State.Q, Action.N),
+    # "other"
+    (State.X, CharacterClass.X): (State.X, Action.I),
+    (State.X, CharacterClass.S): (State.S, Action.I),
+    (State.X, CharacterClass.A): (State.A, Action.I),
+    (State.X, CharacterClass.N): (State.N, Action.I),
+    (State.X, CharacterClass.B): (State.A, Action.I),
+    (State.X, CharacterClass.NUMERIC): (State.NUMERIC, Action.I),
+    (State.X, CharacterClass.D): (State.X, Action.X),
+    (State.X, CharacterClass.C): (State.X, Action.X),
+    (State.X, CharacterClass.Q): (State.Q, Action.I),
+    # "alphanumeric"
+    (State.A, CharacterClass.X): (State.X, Action.I),
+    (State.A, CharacterClass.S): (State.S, Action.I),
+    (State.A, CharacterClass.A): (State.A, Action.X),
+    (State.A, CharacterClass.N): (State.A, Action.X),
+    (State.A, CharacterClass.B): (State.A, Action.X),
+    (State.A, CharacterClass.NUMERIC): (State.A, Action.X),
+    (State.A, CharacterClass.D): (State.X, Action.X),
+    (State.A, CharacterClass.C): (State.X, Action.X),
+    (State.A, CharacterClass.Q): (State.Q, Action.I),
+    # Action.N
+    (State.N, CharacterClass.X): (State.X, Action.I),
+    (State.N, CharacterClass.S): (State.S, Action.I),
+    (State.N, CharacterClass.A): (State.A, Action.X),
+    (State.N, CharacterClass.N): (State.A, Action.X),
+    (State.N, CharacterClass.B): (State.NB, Action.X),
+    (State.N, CharacterClass.NUMERIC): (State.A, Action.X),
+    (State.N, CharacterClass.D): (State.X, Action.X),
+    (State.N, CharacterClass.C): (State.X, Action.X),
+    (State.N, CharacterClass.Q): (State.Q, Action.I),
+    # "NB"
+    (State.NB, CharacterClass.X): (State.X, Action.I),
+    (State.NB, CharacterClass.S): (State.S, Action.I),
+    (State.NB, CharacterClass.A): (State.A, Action.X),
+    (State.NB, CharacterClass.N): (State.A, Action.X),
+    (State.NB, CharacterClass.B): (State.A, Action.X),
+    (State.NB, CharacterClass.NUMERIC): (State.A, Action.X),
+    (State.NB, CharacterClass.D): (State.Z, Action.X),
+    (State.NB, CharacterClass.C): (State.X, Action.X),
+    (State.NB, CharacterClass.Q): (State.Q, Action.I),
+    # "Z"
+    (State.Z, CharacterClass.X): (State.Z, Action.X),
+    (State.Z, CharacterClass.S): (State.Z, Action.X),
+    (State.Z, CharacterClass.A): (State.Z, Action.X),
+    (State.Z, CharacterClass.N): (State.Z, Action.X),
+    (State.Z, CharacterClass.B): (State.Z, Action.X),
+    (State.Z, CharacterClass.NUMERIC): (State.Z, Action.X),
+    (State.Z, CharacterClass.D): (State.X, Action.X),
+    (State.Z, CharacterClass.C): (State.X, Action.X),
+    (State.Z, CharacterClass.Q): (State.Z, Action.X),
+    # "NINE"
+    (State.NUMERIC, CharacterClass.X): (State.X, Action.I),
+    (State.NUMERIC, CharacterClass.S): (State.S, Action.I),
+    (State.NUMERIC, CharacterClass.A): (State.NUMERIC, Action.X),
+    (State.NUMERIC, CharacterClass.N): (State.NUMERIC, Action.X),
+    (State.NUMERIC, CharacterClass.B): (State.NUMERIC, Action.X),
+    (State.NUMERIC, CharacterClass.NUMERIC): (State.NUMERIC, Action.X),
+    (State.NUMERIC, CharacterClass.D): (State.NUMERIC, Action.X),
+    (State.NUMERIC, CharacterClass.C): (State.X, Action.X),
+    (State.NUMERIC, CharacterClass.Q): (State.Q, Action.I),
+    # "Q"
+    (State.Q, CharacterClass.X): (State.Q, Action.X),
+    (State.Q, CharacterClass.S): (State.Q, Action.X),
+    (State.Q, CharacterClass.A): (State.Q, Action.X),
+    (State.Q, CharacterClass.N): (State.Q, Action.X),
+    (State.Q, CharacterClass.B): (State.Q, Action.X),
+    (State.Q, CharacterClass.NUMERIC): (State.Q, Action.X),
+    (State.Q, CharacterClass.D): (State.Q, Action.X),
+    (State.Q, CharacterClass.C): (State.Q, Action.X),
+    (State.Q, CharacterClass.Q): (State.QQ, Action.X),
+    # "QQ"
+    (State.QQ, CharacterClass.X): (State.X, Action.I),
+    (State.QQ, CharacterClass.S): (State.S, Action.I),
+    (State.QQ, CharacterClass.A): (State.A, Action.I),
+    (State.QQ, CharacterClass.N): (State.N, Action.I),
+    (State.QQ, CharacterClass.B): (State.A, Action.I),
+    (State.QQ, CharacterClass.NUMERIC): (State.NUMERIC, Action.I),
+    (State.QQ, CharacterClass.D): (State.X, Action.I),
+    (State.QQ, CharacterClass.C): (State.X, Action.I),
+    (State.QQ, CharacterClass.Q): (State.Q, Action.X),
+}
+
+
+def get_character_class(char: str) -> CharacterClass:
+    if char.isspace():
+        return CharacterClass.S
+
+    if char == "N":
+        return CharacterClass.N
+
+    if char == "B":
+        return CharacterClass.B
+
+    if char.isalpha():
+        return CharacterClass.A
+
+    if char.isdigit() or char == "_":
+        return CharacterClass.NUMERIC
+
+    if char == ".":
+        return CharacterClass.D
+
+    if char == ":":
+        return CharacterClass.C
+
+    if char == "'":
+        return CharacterClass.Q
+
+    return CharacterClass.X
+
+
+def form_words(sentence: str) -> list[Word]:
+    if len(sentence) == 0:
+        return []
+
+    # Append whitespace EOS marker to ensure that the final word is emitted.
+    # This has the side effect that comments and unterminated quotes will not
+    # be emitted, so we handle this later in the function.
+    sentence += "\n"
+
+    i = j = 0
+    current_state: State = State.S
+
+    words: list[Word] = []
+
+    # A sequence of numbers separated by whitespace is treated as a single word in J.
+    # Set a flag to handle this when the current numeric word needs to be emitted.
+    continue_numeric = False
+
+    while i < len(sentence):
+        char = sentence[i]
+        char_class = get_character_class(char)
+        new_state, action = STATE_TRANSITION[(current_state, char_class)]
+
+        if (
+            words
+            and words[-1].is_numeric
+            and current_state == State.S
+            and new_state == State.NUMERIC
+        ):
+            continue_numeric = True
+
+        if action == Action.I:
+            if continue_numeric:
+                prev_word = words.pop()
+                value = sentence[prev_word.start : i]
+                word = Word(value=value, is_numeric=True, start=prev_word.start, end=i)
+                words.append(word)
+                continue_numeric = False
+
+            else:
+                value = sentence[j:i]
+                is_numeric = current_state == State.NUMERIC
+                word = Word(value=value, is_numeric=is_numeric, start=j, end=i)
+                words.append(word)
+
+            j = i
+
+        elif action == Action.N:
+            j = i
+
+        current_state = new_state
+        i += 1
+
+    remaining_word = sentence[j : i - 1]  # i-1 to exclude EOS marker.
+    if remaining_word and not remaining_word.isspace():
+        words.append(Word(value=remaining_word, is_numeric=False, start=j, end=i - 1))
+
+    return words

jinx/word_spelling.py

@@ -0,0 +1,118 @@
+"""Word Spelling.
+
+Given constituent words of a sentence, associate it a part of speech (noun,
+verb, adverb, etc.).
+
+Parsing of numeric constants is also done here.
+
+If a word does not map to a recognised part of speech, raise a SpellingError.
+
+"""
+
+import re
+
+from jinx.errors import SpellingError
+from jinx.primitives import PRIMITIVES
+from jinx.vocabulary import (
+    Comment,
+    DataType,
+    Name,
+    Noun,
+    PartOfSpeechT,
+    Punctuation,
+    Word,
+)
+
+
+def parse_integer(word: str) -> int | None:
+    # Integers are a sequence of digits, optionally terminated
+    # by a single decimal point (which can be followed by any number
+    # of trailing 0s), or a single 'x' (denoting extended precision)
+    # and ignored here as all Python integers are extended precision).
+    match = re.fullmatch(r"_?(\d+)(?:x|\.0*)?", word)
+    if not match:
+        return None
+
+    value = int(match.group(1))
+    return -value if word.startswith("_") else value
+
+
+def parse_float(word: str) -> float | None:
+    if word == "_":
+        return float("inf")
+    if word == "__":
+        return float("-inf")
+    if not re.fullmatch(r"_?\d+\.\d*", word):
+        return None
+    if word.startswith("_"):
+        return -float(word[1:])
+    return float(word)
+
+
+def spell_numeric(word: Word) -> Noun:
+    values = word.value.split()
+    numbers: list[int | float] = []
+    data_type = DataType.Integer
+
+    for value in values:
+        int_value = parse_integer(value)
+        if int_value is not None:
+            numbers.append(int_value)
+            continue
+
+        float_value = parse_float(value)
+        if float_value is not None:
+            numbers.append(float_value)
+            data_type = DataType.Float
+            continue
+
+        raise SpellingError(f"Ill-formed number: {value}")
+
+    return Noun(data_type=data_type, data=numbers)
+
+
+def spell_quoted(word: Word) -> Noun:
+    data = word.value[1:-1]
+    return Noun(data_type=DataType.Byte, data=list(data))
+
+
+PRIMITIVE_MAP = {primitive.spelling: primitive for primitive in PRIMITIVES}
+
+PUNCTUATION_MAP = {
+    "(": Punctuation(spelling="(", name="LPAREN"),
+    ")": Punctuation(spelling=")", name="RPAREN"),
+    "'": Punctuation(spelling="'", name="QUOTE"),
+}
+
+
+def spell(word: Word) -> PartOfSpeechT:
+    if word.value in PRIMITIVE_MAP:
+        return PRIMITIVE_MAP[word.value]
+
+    if word.value in PUNCTUATION_MAP:
+        return PUNCTUATION_MAP[word.value]
+
+    if word.is_numeric:
+        return spell_numeric(word)
+
+    if word.value[0] == "'" and word.value[-1] == "'":
+        return spell_quoted(word)
+
+    if word.value.startswith("NB."):
+        return Comment(spelling=word.value)
+
+    if word[0].isalpha():
+        # Only a restricted form of simple names are supported (alphanumeric).
+        # This is to avoid the complexity of parsing J's full name grammar which
+        # has rules for underscores to support locatives (locales / namespaces).
+        #
+        # See: https://code.jsoftware.com/wiki/Vocabulary/Locales#Locatives
+        if not word.value.isalnum():
+            raise SpellingError(f"Only alphanumeric names are supported: {word.value}")
+        return Name(spelling=word.value)
+
+    raise SpellingError(f"Unrecognised word: {word}")
+
+
+def spell_words(words: list[Word]) -> list[PartOfSpeechT]:
+    return [spell(word) for word in words]

jjinx-0.0.1.dist-info/METADATA

@@ -0,0 +1,148 @@
+Metadata-Version: 2.4
+Name: jjinx
+Version: 0.0.1
+Summary: Interpreter for the J programming language.
+Author: Alex Riley
+License: MIT License
+        
+        Copyright (c) 2025 Alex Riley
+        
+        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.
+        
+Project-URL: Homepage, https://github.com/ajcr/jinx
+Keywords: J,interpreter
+Classifier: Development Status :: 3 - Alpha
+Classifier: Topic :: Scientific/Engineering :: Mathematics
+Classifier: Topic :: Utilities
+Classifier: Typing :: Typed
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3.13
+Requires-Python: >=3.13
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=2.3.3
+Dynamic: license-file
+
+# Jinx
+
+![ci](https://github.com/ajcr/jinx/actions/workflows/ci.yaml/badge.svg?branch=main)
+
+An experimental interpreter for the J programming language, built on top of [NumPy](https://numpy.org/).
+
+Implements many of J's primitives and tacit programming capabilities, and can be extended to support execution via other frameworks too.
+
+## Executing J
+
+Start the interactive shell:
+```sh
+jinx
+```
+The shell prompt is four spaces, so commands appear indented. Internally, all multidimensional arrays are NumPy arrays. Verbs, conjunctions and adverbs are a mixture of Python and NumPy methods.
+
+Here are some examples what Jinx can do so far:
+
+- Solve the "trapping rainwater" problem (solution taken from [here](https://mmapped.blog/posts/04-square-joy-trapped-rain-water)):
+```j
+    +/@((>./\ <. >./\.)-]) 0 1 0 2 1 0 1 3 2 1 2 1
+6
+```
+- Compute the correlation between two arrays of numbers (taken from [here](https://stackoverflow.com/a/44845495/3923281)). This is a complex combination of different verbs, adverbs, conjunctions and trains:
+```j
+    2 1 1 7 9 (+/@:* % *&(+/)&.:*:)&(- +/%#) 6 3 1 5 7
+0.721332
+```
+- Create identity matrices in inventive ways (see [this essay](https://code.jsoftware.com/wiki/Essays/Identity_Matrix)):
+```j
+    |.@~:\ @ ($&0) 3
+1 0 0
+0 1 0
+0 0 1
+
+    (i.@,~ = >: * i.) 3
+1 0 0
+0 1 0
+0 0 1
+
+    ((={:)\ @ i.) 3
+1 0 0
+0 1 0
+0 0 1
+```
+- Solve the Josephus problem (see [this essay](https://code.jsoftware.com/wiki/Essays/Josephus_Problem)). Calculate the survivor's number for a circle of people of size N. Note the use of verb obverse and the rank conjunction:
+```j
+    (1&|.&.#:)"0 >: i. 5 10    NB. N ranges from 1 to 50 here (arranged as a table)
+ 1  1  3  1  3  5  7  1  3  5
+ 7  9 11 13 15  1  3  5  7  9
+11 13 15 17 19 21 23 25 27 29
+31  1  3  5  7  9 11 13 15 17
+19 21 23 25 27 29 31 33 35 37
+```
+- Build nested boxes containing heterogeneous data types and print the contents:
+```j
+    (<<'abc'),(<(<'de',.'fg'),(<<i. 5 2)),(<(<"0 ] % i. 2 2 3))
+┌─────┬──────────┬────────────────────────────┐
+│┌───┐│┌──┬─────┐│┌────────┬────────┬────────┐│
+││abc│││df│┌───┐│││_       │1       │0.5     ││
+│└───┘││eg││0 1│││├────────┼────────┼────────┤│
+│     ││  ││2 3││││0.333333│0.25    │0.2     ││
+│     ││  ││4 5│││└────────┴────────┴────────┘│
+│     ││  ││6 7│││                            │
+│     ││  ││8 9│││┌────────┬────────┬────────┐│
+│     ││  │└───┘│││0.166667│0.142857│0.125   ││
+│     │└──┴─────┘│├────────┼────────┼────────┤│
+│     │          ││0.111111│0.1     │0.090909││
+│     │          │└────────┴────────┴────────┘│
+└─────┴──────────┴────────────────────────────┘
+```
+
+## Easily Customisable
+
+Everything is in Python. Adding new primitives is easy.
+
+Update the `primitives.py` file with your new part of speech (e.g. a new verb such as `+::`). Write your implementation of this new part of speech in the relevant executor module (e.g. `verbs.py`) and then update the name-to-method mapping at the foot of that module. That's all that's needed.
+
+## Alternative Executors
+
+Execution of sentences is backed by NumPy by default.
+
+However Jinx is designed so that it's possible to implement the primitives using alternative frameworks too. Python many Machine Learning and Scientific Programming libraries that could be used to execution J code.
+
+To prove this concept, there's _highly experimental and incomplete_ support for [JAX](https://docs.jax.dev/en/latest/index.html):
+```sh
+jinx --executor jax
+```
+Primitive verbs are JIT compiled and execute on JAX arrays:
+```j
+    mean =: +/ % #
+    mean 33 55 77 100 101
+73.2
+```
+
+## Warning
+
+This project is experimental. There will be bugs, missing features and performance quirks.
+
+Many key parts of J are not currently implemented (but might be in future). These include:
+- Differences in how names are interpreted and resolved at execution time.
+- Locales.
+- Definitions and direct definitions (using `{{ ... }}`).
+- Array types other than floats, integers and and strings.
+- Executing J scripts.
+- Control words.

jjinx-0.0.1.dist-info/RECORD

@@ -0,0 +1,27 @@
+jinx/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+jinx/errors.py,sha256=COssOTL42-Cm9qV9BsyfAxcn__kzHPzn13vI702zflU,540
+jinx/primitives.py,sha256=s-f4fW4-xaPD7Wg2wjj3J6wtYM8AwtvyW3FzW0opH8E,12927
+jinx/shell.py,sha256=27PQ9WjlQo6TC6E0eNuYBy9g2I9-5ykK_UXgW5EQg5M,1822
+jinx/vocabulary.py,sha256=Cvpfviem13lBXN9hYoMAKTTKDtISQzJQ29dCHCEXNh8,4726
+jinx/word_evaluation.py,sha256=c6xYhtooCiiztljiA7cNLX4PwuIAxaBDIEQi5ai7fWo,14359
+jinx/word_formation.py,sha256=5TpE2yNQXk_J_bikOyILpXhv5dFhQCNa9NkeIxUJKSM,8185
+jinx/word_spelling.py,sha256=7Ku8HIiV4FXI37V6bgAJa1WwOxHC6NU1ECAPxtKw6GA,3336
+jinx/execution/executor.py,sha256=_xFu6HYJkrcFq9LljkuWaKXP3IaHREa6nUz-dRfXVWM,1917
+jinx/execution/jax/__init__.py,sha256=xxDNdFZf7P0b-Mhi3_PXovameqYYCTv7X4KQ1A2frqE,1386
+jinx/execution/jax/adverbs.py,sha256=EPxSXSvVkHhZvb1uD7e86MYJ7vzg7u3OYkme_8yamgM,3032
+jinx/execution/jax/application.py,sha256=DYvVn4bRo3FYGVZrakchKL8zBpB0Ux_YmL-Y-dWTmj8,7458
+jinx/execution/jax/verbs.py,sha256=OroFyn9oflmP-GFXNmwAhL2dGt90tnHc0lGMi0ZDFcc,2379
+jinx/execution/numpy/__init__.py,sha256=ISRYr4LARvXrUmzTfMLDb2wIiIMr8Dctosetjo1cWS0,963
+jinx/execution/numpy/adverbs.py,sha256=AsAPue2tTcS4kTQrbkJ0KXjFnQjwGeAoewy1LG1DsCc,11322
+jinx/execution/numpy/application.py,sha256=2NNsYrdN5IaJMjGaaCTNPAZ0Gj-TwdSnL_reBkcnF3w,11254
+jinx/execution/numpy/conjunctions.py,sha256=UJxWhEqvbj9G0CbjD6JoWPazg588K2gawJ9iN8xd0B8,14973
+jinx/execution/numpy/conversion.py,sha256=CmMHqQ4LZVy9HrkItdGmyqGTvmlDZFuV7OH23nxsGKg,2364
+jinx/execution/numpy/helpers.py,sha256=u-RqWnIVLvmyIG-K07Eo3PB1PWyN39ok6jf9uGpOYKs,4875
+jinx/execution/numpy/printing.py,sha256=ksfNJ_VrXufs8NdIaFIyfTTEa92bhhKN6gd50j4T414,5306
+jinx/execution/numpy/verbs.py,sha256=MxSyrmdfizhdV5K9O3uP9Ot9hG-HYxnubupqxZ35Zbs,26152
+jjinx-0.0.1.dist-info/licenses/LICENSE,sha256=6aTGTYWpwS1y9Qc1yWYCL4fZiBLDOGKpmw0GegZEh98,1067
+jjinx-0.0.1.dist-info/METADATA,sha256=LM0pNYqLd8PbrN1Uu5ZLp5Xg1wOHpa6tkiDSY-ylimk,6690
+jjinx-0.0.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+jjinx-0.0.1.dist-info/entry_points.txt,sha256=pQ_2hEqrVOvVmIXehwmyDPLe-uFuPNrhHcpwipywlkU,41
+jjinx-0.0.1.dist-info/top_level.txt,sha256=9RpSfRWqww0qsjO178PgxSOG5FIkU1nuzSbNgF_v9Eg,5
+jjinx-0.0.1.dist-info/RECORD,,

jjinx-0.0.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

jjinx-0.0.1.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+jinx = jinx.shell:main

jjinx-0.0.1.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Alex Riley
+
+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.

jjinx-0.0.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+jinx