jaclang 0.7.33__py3-none-any.whl → 0.8.0__py3-none-any.whl

jaclang/vendor/cattrs-23.2.3.dist-info/METADATA

@@ -1,221 +0,0 @@
-Metadata-Version: 2.1
-Name: cattrs
-Version: 23.2.3
-Summary: Composable complex class support for attrs and dataclasses.
-Project-URL: Homepage, https://catt.rs
-Project-URL: Changelog, https://catt.rs/en/latest/history.html
-Project-URL: Bug Tracker, https://github.com/python-attrs/cattrs/issues
-Project-URL: Repository, https://github.com/python-attrs/cattrs
-Project-URL: Documentation, https://catt.rs/en/stable/
-Author-email: Tin Tvrtkovic <tinchester@gmail.com>
-License: MIT
-License-File: LICENSE
-Keywords: attrs,dataclasses,serialization
-Classifier: Development Status :: 5 - Production/Stable
-Classifier: Intended Audience :: Developers
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Programming Language :: Python :: 3.8
-Classifier: Programming Language :: Python :: 3.9
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
-Classifier: Programming Language :: Python :: Implementation :: CPython
-Classifier: Programming Language :: Python :: Implementation :: PyPy
-Classifier: Typing :: Typed
-Requires-Python: >=3.8
-Requires-Dist: attrs>=23.1.0
-Requires-Dist: exceptiongroup>=1.1.1; python_version < '3.11'
-Requires-Dist: typing-extensions!=4.6.3,>=4.1.0; python_version < '3.11'
-Provides-Extra: bson
-Requires-Dist: pymongo>=4.4.0; extra == 'bson'
-Provides-Extra: cbor2
-Requires-Dist: cbor2>=5.4.6; extra == 'cbor2'
-Provides-Extra: msgpack
-Requires-Dist: msgpack>=1.0.5; extra == 'msgpack'
-Provides-Extra: orjson
-Requires-Dist: orjson>=3.9.2; implementation_name == 'cpython' and extra == 'orjson'
-Provides-Extra: pyyaml
-Requires-Dist: pyyaml>=6.0; extra == 'pyyaml'
-Provides-Extra: tomlkit
-Requires-Dist: tomlkit>=0.11.8; extra == 'tomlkit'
-Provides-Extra: ujson
-Requires-Dist: ujson>=5.7.0; extra == 'ujson'
-Description-Content-Type: text/markdown
-
-# cattrs
-
-<a href="https://pypi.python.org/pypi/cattrs"><img src="https://img.shields.io/pypi/v/cattrs.svg"/></a>
-<a href="https://github.com/python-attrs/cattrs/actions?workflow=CI"><img src="https://github.com/python-attrs/cattrs/workflows/CI/badge.svg"/></a>
-<a href="https://catt.rs/en/latest/?badge=latest"><img src="https://readthedocs.org/projects/cattrs/badge/?version=latest" alt="Documentation Status"/></a>
-<a href="https://github.com/python-attrs/cattrs"><img src="https://img.shields.io/pypi/pyversions/cattrs.svg" alt="Supported Python versions"/></a>
-<a href="https://github.com/python-attrs/cattrs/actions/workflows/main.yml"><img src="https://img.shields.io/endpoint?url=https://gist.githubusercontent.com/Tinche/22405310d6a663164d894a2beab4d44d/raw/covbadge.json"/></a>
-<a href="https://github.com/psf/black"><img src="https://img.shields.io/badge/code%20style-black-000000.svg"/></a>
-
----
-
-**cattrs** is an open source Python library for structuring and unstructuring
-data. _cattrs_ works best with _attrs_ classes, dataclasses and the usual
-Python collections, but other kinds of classes are supported by manually
-registering converters.
-
-Python has a rich set of powerful, easy to use, built-in data types like
-dictionaries, lists and tuples. These data types are also the lingua franca
-of most data serialization libraries, for formats like json, msgpack, cbor,
-yaml or toml.
-
-Data types like this, and mappings like `dict` s in particular, represent
-unstructured data. Your data is, in all likelihood, structured: not all
-combinations of field names or values are valid inputs to your programs. In
-Python, structured data is better represented with classes and enumerations.
-_attrs_ is an excellent library for declaratively describing the structure of
-your data, and validating it.
-
-When you're handed unstructured data (by your network, file system, database...),
-_cattrs_ helps to convert this data into structured data. When you have to
-convert your structured data into data types other libraries can handle,
-_cattrs_ turns your classes and enumerations into dictionaries, integers and
-strings.
-
-Here's a simple taste. The list containing a float, an int and a string
-gets converted into a tuple of three ints.
-
-```python
->>> import cattrs
-
->>> cattrs.structure([1.0, 2, "3"], tuple[int, int, int])
-(1, 2, 3)
-```
-
-_cattrs_ works well with _attrs_ classes out of the box.
-
-```python
->>> from attrs import frozen
->>> import cattrs
-
->>> @frozen  # It works with non-frozen classes too.
-... class C:
-...     a: int
-...     b: str
-
->>> instance = C(1, 'a')
->>> cattrs.unstructure(instance)
-{'a': 1, 'b': 'a'}
->>> cattrs.structure({'a': 1, 'b': 'a'}, C)
-C(a=1, b='a')
-```
-
-Here's a much more complex example, involving `attrs` classes with type
-metadata.
-
-```python
->>> from enum import unique, Enum
->>> from typing import Optional, Sequence, Union
->>> from cattrs import structure, unstructure
->>> from attrs import define, field
-
->>> @unique
-... class CatBreed(Enum):
-...     SIAMESE = "siamese"
-...     MAINE_COON = "maine_coon"
-...     SACRED_BIRMAN = "birman"
-
->>> @define
-... class Cat:
-...     breed: CatBreed
-...     names: Sequence[str]
-
->>> @define
-... class DogMicrochip:
-...     chip_id = field()  # Type annotations are optional, but recommended
-...     time_chipped: float = field()
-
->>> @define
-... class Dog:
-...     cuteness: int
-...     chip: Optional[DogMicrochip] = None
-
->>> p = unstructure([Dog(cuteness=1, chip=DogMicrochip(chip_id=1, time_chipped=10.0)),
-...                  Cat(breed=CatBreed.MAINE_COON, names=('Fluffly', 'Fluffer'))])
-
->>> print(p)
-[{'cuteness': 1, 'chip': {'chip_id': 1, 'time_chipped': 10.0}}, {'breed': 'maine_coon', 'names': ('Fluffly', 'Fluffer')}]
->>> print(structure(p, list[Union[Dog, Cat]]))
-[Dog(cuteness=1, chip=DogMicrochip(chip_id=1, time_chipped=10.0)), Cat(breed=<CatBreed.MAINE_COON: 'maine_coon'>, names=['Fluffly', 'Fluffer'])]
-```
-
-Consider unstructured data a low-level representation that needs to be converted
-to structured data to be handled, and use `structure`. When you're done,
-`unstructure` the data to its unstructured form and pass it along to another
-library or module. Use [attrs type metadata](http://attrs.readthedocs.io/en/stable/examples.html#types)
-to add type metadata to attributes, so _cattrs_ will know how to structure and
-destructure them.
-
-- Free software: MIT license
-- Documentation: https://catt.rs
-- Python versions supported: 3.8 and up. (Older Python versions are supported by older versions; see the changelog.)
-
-## Features
-
-- Converts structured data into unstructured data, recursively:
-
-  - _attrs_ classes and dataclasses are converted into dictionaries in a way similar to `attrs.asdict`, or into tuples in a way similar to `attrs.astuple`.
-  - Enumeration instances are converted to their values.
-  - Other types are let through without conversion. This includes types such as
-    integers, dictionaries, lists and instances of non-_attrs_ classes.
-  - Custom converters for any type can be registered using `register_unstructure_hook`.
-
-- Converts unstructured data into structured data, recursively, according to
-  your specification given as a type. The following types are supported:
-
-  - `typing.Optional[T]`.
-  - `typing.List[T]`, `typing.MutableSequence[T]`, `typing.Sequence[T]` (converts to a list).
-  - `typing.Tuple` (both variants, `Tuple[T, ...]` and `Tuple[X, Y, Z]`).
-  - `typing.MutableSet[T]`, `typing.Set[T]` (converts to a set).
-  - `typing.FrozenSet[T]` (converts to a frozenset).
-  - `typing.Dict[K, V]`, `typing.MutableMapping[K, V]`, `typing.Mapping[K, V]` (converts to a dict).
-  - `typing.TypedDict`.
-  - _attrs_ classes with simple attributes and the usual `__init__`.
-
-    - Simple attributes are attributes that can be assigned unstructured data,
-      like numbers, strings, and collections of unstructured data.
-
-  - All _attrs_ classes and dataclasses with the usual `__init__`, if their complex attributes have type metadata.
-  - `typing.Union` s of supported _attrs_ classes, given that all of the classes have a unique field.
-  - `typing.Union` s of anything, given that you provide a disambiguation function for it.
-  - Custom converters for any type can be registered using `register_structure_hook`.
-
-_cattrs_ comes with preconfigured converters for a number of serialization libraries, including json, msgpack, cbor2, bson, yaml and toml.
-For details, see the [cattrs.preconf package](https://catt.rs/en/stable/preconf.html).
-
-## Design Decisions
-
-_cattrs_ is based on a few fundamental design decisions.
-
-- Un/structuring rules are separate from the models.
-  This allows models to have a one-to-many relationship with un/structuring rules, and to create un/structuring rules for models which you do not own and you cannot change.
-  (_cattrs_ can be configured to use un/structuring rules from models using the [`use_class_methods` strategy](https://catt.rs/en/latest/strategies.html#using-class-specific-structure-and-unstructure-methods).)
-- Invent as little as possible; reuse existing ordinary Python instead.
-  For example, _cattrs_ did not have a custom exception type to group exceptions until the sanctioned Python [`exceptiongroups`](https://docs.python.org/3/library/exceptions.html#ExceptionGroup).
-  A side-effect of this design decision is that, in a lot of cases, when you're solving _cattrs_ problems you're actually learning Python instead of learning _cattrs_.
-- Refuse the temptation to guess.
-  If there are two ways of solving a problem, _cattrs_ should refuse to guess and let the user configure it themselves.
-
-A foolish consistency is the hobgoblin of little minds so these decisions can and are sometimes broken, but they have proven to be a good foundation.
-
-## Additional documentation and talks
-
-- [On structured and unstructured data, or the case for cattrs](https://threeofwands.com/on-structured-and-unstructured-data-or-the-case-for-cattrs/)
-- [Why I use attrs instead of pydantic](https://threeofwands.com/why-i-use-attrs-instead-of-pydantic/)
-- [cattrs I: un/structuring speed](https://threeofwands.com/why-cattrs-is-so-fast/)
-- [Python has a macro language - it's Python (PyCon IT 2022)](https://www.youtube.com/watch?v=UYRSixikUTo)
-- [Intro to cattrs 23.1](https://threeofwands.com/intro-to-cattrs-23-1-0/)
-
-## Credits
-
-Major credits to Hynek Schlawack for creating [attrs](https://attrs.org) and its predecessor, [characteristic](https://github.com/hynek/characteristic).
-
-_cattrs_ is tested with [Hypothesis](http://hypothesis.readthedocs.io/en/latest/), by David R. MacIver.
-
-_cattrs_ is benchmarked using [perf](https://github.com/haypo/perf) and [pytest-benchmark](https://pytest-benchmark.readthedocs.io/en/latest/index.html).
-
-This package was created with [Cookiecutter](https://github.com/audreyr/cookiecutter) and the [`audreyr/cookiecutter-pypackage`](https://github.com/audreyr/cookiecutter-pypackage) project template.

jaclang/vendor/cattrs-23.2.3.dist-info/RECORD

@@ -1,48 +0,0 @@
-cattr/__init__.py,sha256=pODFKaZ7MisyHe_XPc9X6KKG73mqduHUvQO142XwijY,906
-cattr/converters.py,sha256=rQhY4J8r7QTZh5WICuFe4GWO1v0DS3DgQ9r569zd6jg,192
-cattr/disambiguators.py,sha256=ugD1fq1Z5x1pGu5P1lMzcT-IEi1q7IfQJIHEdmg62vM,103
-cattr/dispatch.py,sha256=uVEOgHWR9Hn5tm-wIw-bDccqrxJByVi8yRKaYyvL67k,125
-cattr/errors.py,sha256=V4RhoCObwGrlaM3oyn1H_FYxGR8iAB9dG5NxFDYM548,343
-cattr/gen.py,sha256=3YO5IOioAd5so_ksyWgvevMS0d4L95Ny4fVzt_wFYrM,520
-cattr/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-cattr/preconf/__init__.py,sha256=NqPE7uhVfcP-PggkUpsbfAutMo8oHjcoB1cvjgLft-s,78
-cattr/preconf/bson.py,sha256=xSFxZt7xMGu95YtXH93NRa89CxraZe48NxlNibS9lBM,194
-cattr/preconf/json.py,sha256=5cTWOrN3JjiDFi1eSwiov10ctGANG9gWWGZyd28B3U8,205
-cattr/preconf/msgpack.py,sha256=r6zBT4tw3k44EHWrS6Hwb49CLDGvBOJwJ0GmwZyPvjk,206
-cattr/preconf/orjson.py,sha256=wHbxW6sojjQLTLSyd2MCZNBH5DStt88P655W7ofOw98,202
-cattr/preconf/pyyaml.py,sha256=qJf_63_dnfTpUhlQEnVJTw_XqyYx2f9-WmDKhhvd1k0,202
-cattr/preconf/tomlkit.py,sha256=K8YxxJNO0-CKsE6tHLllz57sot4RrPD0mnLUbRBh80U,206
-cattr/preconf/ujson.py,sha256=VNJR4wxvLsJJsp9cjGRPPYIclNvmy-2BPveb4s1nygA,198
-cattrs/__init__.py,sha256=J0gqMAVuFSFMKO9xvmK_BEY5RSX5J_-Vpmm4dAP7GPE,1631
-cattrs/_compat.py,sha256=xTfkaUu-lnSNSN-YzY_BaufqrIxGYgAHWHblx0yGYxY,14543
-cattrs/_generics.py,sha256=06Xddc7PgaZn2xdSSQ3dYId-wl2YRMObi72d35cyzvY,678
-cattrs/converters.py,sha256=DMDHIsM1hlWRkYtTwZH413bX8Y1_lsbCXRJPKvK0SNw,43247
-cattrs/disambiguators.py,sha256=5KNEFA8W64aJtDqpIqilTT66DNKytquTIpqozbamwcQ,4820
-cattrs/dispatch.py,sha256=LEn_N50Pa7GEgfgxtoJIs-B4nCLLB2nRNFCsL1ddL64,5425
-cattrs/errors.py,sha256=rHps9Qp7SoRafb2VuAkMbhsQf4pq87gX1SzM-jluMsE,4070
-cattrs/fns.py,sha256=aw8wsFMzX086-PwunbRA8JWAAiDOXr2jkxex7otx63I,476
-cattrs/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-cattrs/v.py,sha256=24ZP67PqBfmsOkQg9k2oiajGyxMJdtX7UpNqKJGEtT4,4398
-cattrs/gen/__init__.py,sha256=TuUdEL480y_Rrv750OkmTjRjsHJ3lodC--hs6s8ATs0,33081
-cattrs/gen/_consts.py,sha256=ZwT_m2J3S7p-UjltpbA1WtfQZLNj9KhmFYCAv6Zl-g0,511
-cattrs/gen/_generics.py,sha256=abzK7_p3bidhtk6NVRc2I7yrZgYDNKQvaQasbPd0d9Y,1489
-cattrs/gen/_lc.py,sha256=d6MixR8VTJGcOA_gOoxZnD94NLbHhw8hOijS4xAg_8U,909
-cattrs/gen/_shared.py,sha256=ALUnTyDETS0UFnwQEhM8m6OyiBMduTQcUT0kS7e8HDA,1748
-cattrs/gen/typeddicts.py,sha256=2N-QcC0vojgAnplIqRF-y1YIGHoJvRiK73K1Vk0OrFE,22438
-cattrs/preconf/__init__.py,sha256=llrsaQAQ_c6gf6niLeNDvzLNxXajVyQwr1BDLe_cuTo,165
-cattrs/preconf/bson.py,sha256=qlXs6NBfFX7D87_YnXV9xv8RiN6tB35vq9k0VRxOP-w,3628
-cattrs/preconf/cbor2.py,sha256=ovFLVc1SesQPJh7WaDla8PZABjs7qUDMfnAWkje3__U,1593
-cattrs/preconf/json.py,sha256=71_6nHgogI8LSjvRuB-79KgDucfcuvpVtUAUaK_Cf0A,1911
-cattrs/preconf/msgpack.py,sha256=6Z64ZylbQSdH3aX_7PaRJ-rTl-Hxc70fmt_vB_4Ciyo,1709
-cattrs/preconf/orjson.py,sha256=T5Eh5bZz70Jp4BQFuJnY1tix8fKV_StBSj2QrgJnJa0,2908
-cattrs/preconf/pyyaml.py,sha256=Gwpo6FZDMvJz0ICFvO4VSCoMrHTRoWb7RXUDm9pptuE,1915
-cattrs/preconf/tomlkit.py,sha256=uPss8xeON003qeBXFtBGKP_jHlawwMP6acyPIemWC5g,3029
-cattrs/preconf/ujson.py,sha256=KdCc36J3brJcb-44qIhcmKx0KO7dggHj2Go7qYHqG2Y,1821
-cattrs/strategies/__init__.py,sha256=xcT8bN-qcs7GMB5N4vWe6x5v8EBDTN84x8cO0D7HbqI,338
-cattrs/strategies/_class_methods.py,sha256=ngOy-EIB3RGx0jfUYPCYoC77BEnt0YaakhbDPEgz4g8,2601
-cattrs/strategies/_subclasses.py,sha256=DG1KYrUl78tYN5RYEaX6YIZv7X4vmYdFIktnGqq7p2I,8617
-cattrs/strategies/_unions.py,sha256=w6vrT5wFTyZazSxiyPEHbV9C7oS0z27A6UyRNZfYm70,8368
-cattrs-23.2.3.dist-info/METADATA,sha256=YtvAD8LNF6bPHVRVtcyzNhkJ7k4hpx8xAorDZLyXQ0M,10803
-cattrs-23.2.3.dist-info/WHEEL,sha256=9QBuHhg6FNW7lppboF2vKVbCGTVzsFykgRQjjlajrhA,87
-cattrs-23.2.3.dist-info/licenses/LICENSE,sha256=9fudHt43qIykf0IMSZ3KD0oFvJk-Esd9I1IKrSkcAb8,1074
-cattrs-23.2.3.dist-info/RECORD,,

jaclang/vendor/lark-1.1.9.dist-info/RECORD

@@ -1,46 +0,0 @@
-lark/__init__.py,sha256=eOoOFH7rcPzKXd4rxJPkRl6LL7tMzpvuMjQk1afNHh8,782
-lark/ast_utils.py,sha256=0F8sUE8O1AYrJLbl-DaVYIc5iGWxuzCeybw-am23M7A,2176
-lark/common.py,sha256=4PL55HJGsq_erZjVfmKHL6N3f9-WoN-rwae-ffGA8bo,3192
-lark/exceptions.py,sha256=kb-KYAicBFOXaNlNbloLGO4Im9fzrOjWoLhIn9SaAkE,11231
-lark/grammar.py,sha256=8GvxXySoEMsEHpOuYvFe4QG-Jgb8FWGKh80zgep8r4E,3795
-lark/indenter.py,sha256=tQiJiupGwi82AxhHJfnoTTvrVEux1DWeXdxzDDZiRs0,3174
-lark/lark.py,sha256=Vma7ftpU8ZU06Fzs-cykn84BR5DIzXuy6vOxZGhR66g,28948
-lark/lexer.py,sha256=XOaa7j03rb4mOE6MjrONxDIkT2nOKm9UGx0evt1Lr-c,24715
-lark/load_grammar.py,sha256=vCjrxlYmWlgUqBqCx_XzFSRoXRkQP-k-hDIT-ZZE__M,55374
-lark/parse_tree_builder.py,sha256=7dJkxZTKI7JEfde6u2vvQVItLtKMK0CQOR92_QuWEnY,14803
-lark/parser_frontends.py,sha256=sC80SGfpO_STC04ZjSDgYyuOsLP36i1fwd1-lIZgSY0,10422
-lark/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-lark/reconstruct.py,sha256=VYq_x5n1Beht6-G42tQxJM4_BvEMTMawJCcWOAsgbhI,3870
-lark/tree.py,sha256=_FLqE2-4MRSPUsXIlgM-FUmROeMcnGsXuWS8ElSmz_k,9025
-lark/tree_matcher.py,sha256=CdrRMlkLNTF87X896HK3ax7XFZd-z4zhV7dlwBju3VY,6189
-lark/tree_templates.py,sha256=sSnfw1m8txAkJOYhcQrooG7xajVyVplunzTnNsxY720,6139
-lark/utils.py,sha256=6N1tfllFonTjWK7iVhq3BNXj7K-E1mdfFfuLwtkHEi0,12259
-lark/visitors.py,sha256=sCfr6WanU-rCYZZYE2pg8HIRjpcRL0tJfeq56Tn9qJE,21956
-lark/__pyinstaller/__init__.py,sha256=16uejyuvS4VwfnVtDxk7SRZIzCCMX-j0_DBr39-0-5Y,188
-lark/__pyinstaller/hook-lark.py,sha256=RhJHTAnAeNjs9sqTpAQvAxYPhAKJA2NLKD4oh-IvDuc,613
-lark/grammars/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-lark/grammars/common.lark,sha256=aTv39kqbl8haIV6D88I0-dWf_C6jl3X8y9GKPt7yddE,944
-lark/grammars/lark.lark,sha256=mp2F9PYTmm8Jl7vjjUslEeHrcL9ZwfhJnDlcqhzeAWI,1603
-lark/grammars/python.lark,sha256=p5S5hYeA20GEDAHql8gb4TsZvqfZN36PYrJZhauiokc,10943
-lark/grammars/unicode.lark,sha256=_0Clod4_uthpQK_Cd52ZjTPkNTwHuzI_sYbYDr1yGOg,103
-lark/parsers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-lark/parsers/cyk.py,sha256=JCn8WHR-wYDs8jh58IGZ6TLSik5zuGsxEOale1mX5BQ,12532
-lark/parsers/earley.py,sha256=f5ywWiaEhQ4J4Uu2l5eMDwjEE68ZVD2xSnO-kNbCbTc,14904
-lark/parsers/earley_common.py,sha256=xKxOTEOR28Mcdqxq9kW2ftng2R0lFh5TAE1T8wxszeg,1623
-lark/parsers/earley_forest.py,sha256=yVC-QuVwCVopsrGmBMmvouqFI9lbBsY7z1M-RyYrLcs,32444
-lark/parsers/grammar_analysis.py,sha256=CB74F6imSuvRb7ffztoD3VoIhMZ6cuit0UFr-doximk,7309
-lark/parsers/lalr_analysis.py,sha256=b-XlcyuWIjJqvY-1UEn38FB2tuGV2qla8JQ5jGs767Q,12539
-lark/parsers/lalr_interactive_parser.py,sha256=d5A6QDlkgnQM88ysPpkDyuFpGX3zvZzTfCb5qheoXFA,5781
-lark/parsers/lalr_parser.py,sha256=HKCLf3Lxc8YfzQLA98r4TjBreESzKlGd8vmnxwJKXeE,4708
-lark/parsers/lalr_parser_state.py,sha256=Ii53q514pZgYJqakw1vy-u4gyliHpRU5klwVfNZMhUU,3833
-lark/parsers/xearley.py,sha256=g2Ugz3FS4pJCgjhdR3hoYFqb9RXZMQqS3cJDlywlOKw,7986
-lark/tools/__init__.py,sha256=XG-dXUPh7DP8CC8EZb2b1GpaenKEHO6X-BjsHnYw2v0,2615
-lark/tools/nearley.py,sha256=QaVnT3ilHm9vgOP9vMdpPuDjIKqCsnANlk9WFDq14-0,6467
-lark/tools/serialize.py,sha256=_3uoeHRbvD29t0CZHMcHoWxy19FWQIrp0CN6r54WNl4,997
-lark/tools/standalone.py,sha256=sS18zzBeFp7i7NaWddLd49BDFpmWdn6rOmhA9gVjB1g,5823
-lark-1.1.9.dist-info/LICENSE,sha256=gmPlZS0Hzss62t8FFAtl5wz6Fp7OxfUg_hZxR5zhKoM,1073
-lark-1.1.9.dist-info/METADATA,sha256=6eU3NTAZjd5KuZCVaPAeKzKib0wskofu_815-T5aM8o,1878
-lark-1.1.9.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
-lark-1.1.9.dist-info/entry_points.txt,sha256=WXYg_uCUdFlxQDPUhli3HFah37bNNFQfXLdzCqsacGI,61
-lark-1.1.9.dist-info/top_level.txt,sha256=dyS6jg8hCHHkXWvsfcIMO8rjlv_bdzAxiE0lkkzJ5hk,5
-lark-1.1.9.dist-info/RECORD,,

jaclang/vendor/lark-1.1.9.dist-info/WHEEL

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

jaclang/vendor/mypy/__init__.py

@@ -1 +0,0 @@
-# This page intentionally left blank

jaclang/vendor/mypy/__main__.py

@@ -1,37 +0,0 @@
-"""Mypy type checker command line tool."""
-
-from __future__ import annotations
-
-import os
-import sys
-import traceback
-
-from mypy.main import main, process_options
-from mypy.util import FancyFormatter
-
-
-def console_entry() -> None:
-    try:
-        main()
-        sys.stdout.flush()
-        sys.stderr.flush()
-    except BrokenPipeError:
-        # Python flushes standard streams on exit; redirect remaining output
-        # to devnull to avoid another BrokenPipeError at shutdown
-        devnull = os.open(os.devnull, os.O_WRONLY)
-        os.dup2(devnull, sys.stdout.fileno())
-        sys.exit(2)
-    except KeyboardInterrupt:
-        _, options = process_options(args=sys.argv[1:])
-        if options.show_traceback:
-            sys.stdout.write(traceback.format_exc())
-        formatter = FancyFormatter(sys.stdout, sys.stderr, False)
-        msg = "Interrupted\n"
-        sys.stdout.write(formatter.style(msg, color="red", bold=True))
-        sys.stdout.flush()
-        sys.stderr.flush()
-        sys.exit(2)
-
-
-if __name__ == "__main__":
-    console_entry()

jaclang/vendor/mypy/api.py

@@ -1,94 +0,0 @@
-"""This module makes it possible to use mypy as part of a Python application.
-
-Since mypy still changes, the API was kept utterly simple and non-intrusive.
-It just mimics command line activation without starting a new interpreter.
-So the normal docs about the mypy command line apply.
-Changes in the command line version of mypy will be immediately usable.
-
-Just import this module and then call the 'run' function with a parameter of
-type List[str], containing what normally would have been the command line
-arguments to mypy.
-
-Function 'run' returns a Tuple[str, str, int], namely
-(<normal_report>, <error_report>, <exit_status>),
-in which <normal_report> is what mypy normally writes to sys.stdout,
-<error_report> is what mypy normally writes to sys.stderr and exit_status is
-the exit status mypy normally returns to the operating system.
-
-Any pretty formatting is left to the caller.
-
-The 'run_dmypy' function is similar, but instead mimics invocation of
-dmypy. Note that run_dmypy is not thread-safe and modifies sys.stdout
-and sys.stderr during its invocation.
-
-Note that these APIs don't support incremental generation of error
-messages.
-
-Trivial example of code using this module:
-
-import sys
-from mypy import api
-
-result = api.run(sys.argv[1:])
-
-if result[0]:
-    print('\nType checking report:\n')
-    print(result[0])  # stdout
-
-if result[1]:
-    print('\nError report:\n')
-    print(result[1])  # stderr
-
-print('\nExit status:', result[2])
-
-"""
-
-from __future__ import annotations
-
-import sys
-from io import StringIO
-from typing import Callable, TextIO
-
-
-def _run(main_wrapper: Callable[[TextIO, TextIO], None]) -> tuple[str, str, int]:
-    stdout = StringIO()
-    stderr = StringIO()
-
-    try:
-        main_wrapper(stdout, stderr)
-        exit_status = 0
-    except SystemExit as system_exit:
-        assert isinstance(system_exit.code, int)
-        exit_status = system_exit.code
-
-    return stdout.getvalue(), stderr.getvalue(), exit_status
-
-
-def run(args: list[str]) -> tuple[str, str, int]:
-    # Lazy import to avoid needing to import all of mypy to call run_dmypy
-    from mypy.main import main
-
-    return _run(
-        lambda stdout, stderr: main(args=args, stdout=stdout, stderr=stderr, clean_exit=True)
-    )
-
-
-def run_dmypy(args: list[str]) -> tuple[str, str, int]:
-    from mypy.dmypy.client import main
-
-    # A bunch of effort has been put into threading stdout and stderr
-    # through the main API to avoid the threadsafety problems of
-    # modifying sys.stdout/sys.stderr, but that hasn't been done for
-    # the dmypy client, so we just do the non-threadsafe thing.
-    def f(stdout: TextIO, stderr: TextIO) -> None:
-        old_stdout = sys.stdout
-        old_stderr = sys.stderr
-        try:
-            sys.stdout = stdout
-            sys.stderr = stderr
-            main(args)
-        finally:
-            sys.stdout = old_stdout
-            sys.stderr = old_stderr
-
-    return _run(f)

jaclang/vendor/mypy/applytype.py

@@ -1,172 +0,0 @@
-from __future__ import annotations
-
-from typing import Callable, Sequence
-
-import mypy.subtypes
-from mypy.erasetype import erase_typevars
-from mypy.expandtype import expand_type
-from mypy.nodes import Context
-from mypy.types import (
-    AnyType,
-    CallableType,
-    ParamSpecType,
-    PartialType,
-    Type,
-    TypeVarId,
-    TypeVarLikeType,
-    TypeVarTupleType,
-    TypeVarType,
-    UninhabitedType,
-    UnpackType,
-    get_proper_type,
-)
-
-
-def get_target_type(
-    tvar: TypeVarLikeType,
-    type: Type,
-    callable: CallableType,
-    report_incompatible_typevar_value: Callable[[CallableType, Type, str, Context], None],
-    context: Context,
-    skip_unsatisfied: bool,
-) -> Type | None:
-    p_type = get_proper_type(type)
-    if isinstance(p_type, UninhabitedType) and tvar.has_default():
-        return tvar.default
-    if isinstance(tvar, ParamSpecType):
-        return type
-    if isinstance(tvar, TypeVarTupleType):
-        return type
-    assert isinstance(tvar, TypeVarType)
-    values = tvar.values
-    if values:
-        if isinstance(p_type, AnyType):
-            return type
-        if isinstance(p_type, TypeVarType) and p_type.values:
-            # Allow substituting T1 for T if every allowed value of T1
-            # is also a legal value of T.
-            if all(any(mypy.subtypes.is_same_type(v, v1) for v in values) for v1 in p_type.values):
-                return type
-        matching = []
-        for value in values:
-            if mypy.subtypes.is_subtype(type, value):
-                matching.append(value)
-        if matching:
-            best = matching[0]
-            # If there are more than one matching value, we select the narrowest
-            for match in matching[1:]:
-                if mypy.subtypes.is_subtype(match, best):
-                    best = match
-            return best
-        if skip_unsatisfied:
-            return None
-        report_incompatible_typevar_value(callable, type, tvar.name, context)
-    else:
-        upper_bound = tvar.upper_bound
-        if tvar.name == "Self":
-            # Internally constructed Self-types contain class type variables in upper bound,
-            # so we need to erase them to avoid false positives. This is safe because we do
-            # not support type variables in upper bounds of user defined types.
-            upper_bound = erase_typevars(upper_bound)
-        if not mypy.subtypes.is_subtype(type, upper_bound):
-            if skip_unsatisfied:
-                return None
-            report_incompatible_typevar_value(callable, type, tvar.name, context)
-    return type
-
-
-def apply_generic_arguments(
-    callable: CallableType,
-    orig_types: Sequence[Type | None],
-    report_incompatible_typevar_value: Callable[[CallableType, Type, str, Context], None],
-    context: Context,
-    skip_unsatisfied: bool = False,
-) -> CallableType:
-    """Apply generic type arguments to a callable type.
-
-    For example, applying [int] to 'def [T] (T) -> T' results in
-    'def (int) -> int'.
-
-    Note that each type can be None; in this case, it will not be applied.
-
-    If `skip_unsatisfied` is True, then just skip the types that don't satisfy type variable
-    bound or constraints, instead of giving an error.
-    """
-    tvars = callable.variables
-    min_arg_count = sum(not tv.has_default() for tv in tvars)
-    assert min_arg_count <= len(orig_types) <= len(tvars)
-    # Check that inferred type variable values are compatible with allowed
-    # values and bounds.  Also, promote subtype values to allowed values.
-    # Create a map from type variable id to target type.
-    id_to_type: dict[TypeVarId, Type] = {}
-
-    for tvar, type in zip(tvars, orig_types):
-        assert not isinstance(type, PartialType), "Internal error: must never apply partial type"
-        if type is None:
-            continue
-
-        target_type = get_target_type(
-            tvar, type, callable, report_incompatible_typevar_value, context, skip_unsatisfied
-        )
-        if target_type is not None:
-            id_to_type[tvar.id] = target_type
-
-    # TODO: validate arg_kinds/arg_names for ParamSpec and TypeVarTuple replacements,
-    # not just type variable bounds above.
-    param_spec = callable.param_spec()
-    if param_spec is not None:
-        nt = id_to_type.get(param_spec.id)
-        if nt is not None:
-            # ParamSpec expansion is special-cased, so we need to always expand callable
-            # as a whole, not expanding arguments individually.
-            callable = expand_type(callable, id_to_type)
-            assert isinstance(callable, CallableType)
-            return callable.copy_modified(
-                variables=[tv for tv in tvars if tv.id not in id_to_type]
-            )
-
-    # Apply arguments to argument types.
-    var_arg = callable.var_arg()
-    if var_arg is not None and isinstance(var_arg.typ, UnpackType):
-        # Same as for ParamSpec, callable with variadic types needs to be expanded as a whole.
-        callable = expand_type(callable, id_to_type)
-        assert isinstance(callable, CallableType)
-        return callable.copy_modified(variables=[tv for tv in tvars if tv.id not in id_to_type])
-    else:
-        callable = callable.copy_modified(
-            arg_types=[expand_type(at, id_to_type) for at in callable.arg_types]
-        )
-
-    # Apply arguments to TypeGuard and TypeIs if any.
-    if callable.type_guard is not None:
-        type_guard = expand_type(callable.type_guard, id_to_type)
-    else:
-        type_guard = None
-    if callable.type_is is not None:
-        type_is = expand_type(callable.type_is, id_to_type)
-    else:
-        type_is = None
-
-    # The callable may retain some type vars if only some were applied.
-    # TODO: move apply_poly() logic from checkexpr.py here when new inference
-    # becomes universally used (i.e. in all passes + in unification).
-    # With this new logic we can actually *add* some new free variables.
-    remaining_tvars: list[TypeVarLikeType] = []
-    for tv in tvars:
-        if tv.id in id_to_type:
-            continue
-        if not tv.has_default():
-            remaining_tvars.append(tv)
-            continue
-        # TypeVarLike isn't in id_to_type mapping.
-        # Only expand the TypeVar default here.
-        typ = expand_type(tv, id_to_type)
-        assert isinstance(typ, TypeVarLikeType)
-        remaining_tvars.append(typ)
-
-    return callable.copy_modified(
-        ret_type=expand_type(callable.ret_type, id_to_type),
-        variables=remaining_tvars,
-        type_guard=type_guard,
-        type_is=type_is,
-    )