| Name | psll JSON |
| Version |
0.1.6
JSON |
| download |
| home_page | |
| Summary | Read the latest Real Python tutorials |
| upload_time | 2024-03-18 11:45:10 |
| maintainer | |
| docs_url | None |
| author | |
| requires_python | >=3.9 |
| license | MIT License Copyright (c) 2023 Marcin Konowalczyk 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. |
| keywords |
compiler
macros
code-golf
pyramid-scheme
programming-language
|
| VCS |
 |
| bugtrack_url |
|
| requirements |
No requirements were recorded.
|
| Travis-CI |
|
| coveralls test coverage |
|
# psll-lang <!-- omit in toc -->
[](https://pypi.org/project/psll/) [](https://github.com/MarcinKonowalczyk/psll-lang/actions/workflows/publish.yml) [](https://app.travis-ci.com/MarcinKonowalczyk/psll-lang) [](https://coveralls.io/github/MarcinKonowalczyk/psll-lang?branch=master) [](https://github.com/psf/black)
Macro-driven metalanguage which compiles to [Pyramid Scheme](https://github.com/ConorOBrien-Foxx/Pyramid-Scheme). Read [the paper](./sigbovik-paper/sigbovik-psll.pdf)!
---
- [🔧 Usage](#🔧-usage)
- [💡 Examples](#💡-examples)
- [🧬 Additional features](#🧬-additional-features)
- [Bracket expansion](#Bracket-expansion)
- [Strings](#Strings)
- [Def keyword](#Def-keyword)
- [Command expansion](#Command-expansion)
- [Underscore keyword](#Underscore-keyword)
- [🧚🏻♀️ Code optimisation](#🧚🏻♀️-code-optimisation)
- [Greedy optimisation](#Greedy-optimisation)
- [Considerate optimisation](#Considerate-optimisation)
## 🔧 Usage
Download and install psll:
```sh
cd ~
git clone https://github.com/MarcinKonowalczyk/psll-lang.git
cd psll-lang
pip install .
```
Then `psll` command should be available in your command line. Run `psll --help` to lean more.
You can also skip the installation and run the python module as a script with `python -m psll ...` without any installation.
Only the `compile` command is implemented at the moment, so you'll have to run the resulting pyramid scheme by yourself with, for example, `ruby ./Pyramid-Scheme/pyra.rb ...`.
For example, to compile and run the bubble-sort example:
```sh
psll -v compile ./examples/bubble_sort.psll -o && \
ruby ./Pyramid-Scheme/pyra.rb ./examples/bubble_sort.pyra
```
You can also run the pyramid schem straight from `psll` cli. For that to work, make sure `ruby` is in the path.
```sh
psll run ./examples/bubble_sort.pyra
```
There is also a convenience command to compile a psll program in a temp directory and run it:
```sh
psll -v compile-and-run ./examples/bubble_sort.psll
```
Here it it specified with a `-v` option to also count the number of
## 💡 Examples
The following is an example lisp-like pyramid scheme which counts the number of input arguments it gets, and then prints it out to the command line. The syntax supports `//` comments and newlines, as well as (almost) random additions of whitespace.
For the purposed of the markdown README, C# highlighting seems to look fine. There is a vscode extension in the `psll-lang` folder which provides syntax highlighting for both psll and Pyramid Scheme.
```cs
// Make nil by asking for the 999'th input argument
(set nil (arg 999))
// Count the number of input arguments - n
(set nargin 0)
(do cond (
(set nargin (+ nargin 1))
(set cond (! (= (arg nargin) nil)))
))
(set nargin (- nargin 1))
(out "nargin: " nargin) // Print
```
It can be compiled and run as follows:
```sh
python -m psll ./examples/nargin_counter.psll -o -f
ruby ./Pyramid-Scheme/pyra.rb ./exmaples/nargin_counter.pyra 4 3 5 2 4
```
or with the `compile-and-run`
```sh
psll compile-and-run ./examples/nargin_counter.psll 4 3 5 2 4
```
The output is `nargin: 5`
## 🧬 Additional features
Psll implements a few bits of syntactic sugar, to make writing complicated pyramid schemes easier.
### Bracket expansion
A bracket with multiple subtrees will get automatically split into multiple size-2 subtrees which will, in turn, get prepended with the empty string, as described above. Hence, the following psll code:
```cs
(
(out 1) (out 2) (out 3) (out 4) (out 5)
)
```
will get interpreted as:
```cs
(
(
( // First pair
(out 1) (out 2)
)
( // Second pair
(out 3) (out 4)
)
) // One left
(out 5)
)
```
The elements are taken from the list pairwise, and put into sub-lists recursively, until the root list has length of 2 or less. Because of order of subtree evaluation in pyramid scheme, this preserves the execution order. Note that arbitrary indentation, and mid-line comments are allowed.
This feature is useful, for example, for keeping tidy the body of a for-loop or an if-statement:
```cs
(set a 0) // Flip-flop
(set N 10) (set j 0) // N of iteration and loop counter
(loop (! (= j N)) (
// Do some work...
(out j (chr 32)) // Print j and space
(out a (chr 10)) // Print a and newline
(set a (! a)) // Flip a
(set j (+ j 1))
))
```
### Strings
In pyramid scheme, the strings have to be built manually. The string hello is:
```cs
(set a (+ (+ (+ (+ (chr 72) (chr 101)) (chr 108)) (chr 108)) (chr 111)))
```
Psll expands a string literal into such construct, so its enough to write:
```cs
(set a "Hello")
```
Only `"` can be used to create strings.
### Def keyword
Psll implements `def` as a special keyword. The syntax for `def` is: `(def x (...))`, where `x` can be any string (except `def`) and `(...)` is any bracket. From that point onwards, each occurrence of `x` or `(x)` is replaced by the bracket `(...)`. The `def` statement itself gets replaced by an empty pyramid (hence evaluates to 0). For example:
```cs
(def f (set a (! a))) // This becomes ()
(f) // This becomes (set a (! a))
```
`def` can, therefore be used akin to a function definition:
```cs
(set a 0)
(def incr (set a (+ a 1))) // Increment a
(incr) // This now becomes (set a (+ a 1))
(out "a: " a) (out (chr 10))
```
Once defined, it is possible to redefine `def`'s in terms of themselves:
```cs
(def incr ( // Redefine 'incr' as itself + printing
(incr)
(out "<incr> a: " a)
(out (chr 10)) // Newline
))
(incr) // This now does the original incr + print
```
Defs are active **within the scope in which they are declared**. Hence:
```cs
(def f (incr)) // 'f' is an alias for 'incr'
(f) // This now behaves as 'incr'
(
(out "entering scope" (chr 10))
(def f (out "Vikings approaching!" (chr 10))) // Redefine f within the scope
(f f f) // Do 'f' 3 times
(out "leaving scope" (chr 10))
)
(out "a: " a) (out (chr 10)) // But 'a' remains unchanged
(f) // 'f' works the same way as before the scope
(incr) // and 'incr' also works the same way
```
The code above prints `Vikings approaching!` three times, as opposed to incrementing `a` three times, btu then goes back to incrementing after the scope.
The following is, for example, a *postfix* implementation of the modulo function:
```cs
(def mod (loop (<=> (<=> a b) -1) (set a (- a b)))) // Set a to mod(a,b)
(set a 11) (set b 7) (mod)
```
### Command expansion
The `out` command of Pyramid Scheme allows for output of, at most, 2 variables. To output more, one needs to chain mutiple such `out` statements. In psll an out command with more than two inputs gets automatically expanded into such chain, such that:
```cs
(out a b)
(out c d)
(out e)
```
can be written simply as:
```cs
(out a b c d e)
```
The former might, however be preferable in certain contexts since it allows for comments on each part of the `out`.
A _similar_ expansion will is also implemented for binary operators `+`, `*` as well as `-`, `/`, `^`, `=` and `<=>`, such that:
```cs
(+ 1 2 3 4) // This
(out (+ (+ (+ 1 2) 3) 4) newline) // Becomes this
```
Addition and subtraction are commutative over the set of all possible inputs, and hence the exact order of operations does not matter. (This is not quite true. String multiplication overloads concatenation and that's not commutative). For a non-commutative operation, e.g. subtraction, the expansion order does matter. Hence:
```cs
(- 1 2 3 4) // This
(- (- (- 1 2) 3) 4) // Does indeed expand into this
```
but,
```cs
(1 2 3 4 -) // This
(- 1 (- 2 (- 3 4))) // Expands to this instead
```
For the binary operations listed above, they can be specified at the end of the bracket to perform a right-associative expansion.
For the sake of compatibility with non-expanded brackets, the following two are also allowed, and identical:
```cs
(- 1 2)
(1 2 -)
```
(and, of course, the same for other binary operations, even the commutative ones)
### Underscore keyword
The underscore `_` can be used to explicitly specify an empty slot where a pyramid could be. It is not particularly useful from the user point of view (maybe except for fine-tuning the position of the pyramids for code golf), but it is very helpful for the compiler. All the leaves are eventually terminated with `_`, and string expansion used the `_` keyword to help pack the code a bit better.
## 🧚🏻♀️ Code optimisation
Psll compiler allows for some code optimisation. Optimising the code for speed would be, let's be honest with ourselves, a bit silly at this point. Psll optimisation attempts, therefore, to minimise number of bytes in the source code, such that the result can be used in [code golf challenges](https://codegolf.stackexchange.com/a/208938/68200).
### Greedy optimisation
Attempt to package each pair of root nodes in the abstract syntax tree. Insert an empty pyramid in the very first place which is beneficial (hence _greedy_). If all such places have been exhausted, try all teh possible insertions of a single pyramid.
This optimisation technique tends to result in tall pyramid scheme. It is very fast, and produces intermediate-quality results.
### Considerate optimisation
Consider all the possible places to either insert a single pyramid, or package two adjacent pyramids up to certain depth (10). Choose the most beneficial.
This optimisation technique tends to result in wide pyramid scheme. It is slower than the greedy optimisation, but very often results in a smaller pyramid scheme.
Raw data
{
"_id": null,
"home_page": "",
"name": "psll",
"maintainer": "",
"docs_url": null,
"requires_python": ">=3.9",
"maintainer_email": "",
"keywords": "compiler,macros,code-golf,pyramid-scheme,programming-language",
"author": "",
"author_email": "Marcin Konowalczyk <marcin.konow@lczyk.xyz>",
"download_url": "https://files.pythonhosted.org/packages/e3/a6/4aac05519d1fe973244e54316f53d40075462861d8ccca824da2751b698d/psll-0.1.6.tar.gz",
"platform": null,
"description": "# psll-lang <!-- omit in toc -->\n\n[](https://pypi.org/project/psll/) [](https://github.com/MarcinKonowalczyk/psll-lang/actions/workflows/publish.yml) [](https://app.travis-ci.com/MarcinKonowalczyk/psll-lang) [](https://coveralls.io/github/MarcinKonowalczyk/psll-lang?branch=master) [](https://github.com/psf/black)\n\nMacro-driven metalanguage which compiles to [Pyramid Scheme](https://github.com/ConorOBrien-Foxx/Pyramid-Scheme). Read [the paper](./sigbovik-paper/sigbovik-psll.pdf)!\n\n---\n\n- [\ud83d\udd27 Usage](#\ud83d\udd27-usage)\n- [\ud83d\udca1 Examples](#\ud83d\udca1-examples)\n- [\ud83e\uddec Additional features](#\ud83e\uddec-additional-features)\n - [Bracket expansion](#Bracket-expansion)\n - [Strings](#Strings)\n - [Def keyword](#Def-keyword)\n - [Command expansion](#Command-expansion)\n - [Underscore keyword](#Underscore-keyword)\n- [\ud83e\uddda\ud83c\udffb\u200d\u2640\ufe0f Code optimisation](#\ud83e\uddda\ud83c\udffb\u200d\u2640\ufe0f-code-optimisation)\n - [Greedy optimisation](#Greedy-optimisation)\n - [Considerate optimisation](#Considerate-optimisation)\n\n## \ud83d\udd27 Usage\n\nDownload and install psll:\n\n```sh\ncd ~\ngit clone https://github.com/MarcinKonowalczyk/psll-lang.git\ncd psll-lang\npip install .\n```\n\nThen `psll` command should be available in your command line. Run `psll --help` to lean more.\n\nYou can also skip the installation and run the python module as a script with `python -m psll ...` without any installation. \n\nOnly the `compile` command is implemented at the moment, so you'll have to run the resulting pyramid scheme by yourself with, for example, `ruby ./Pyramid-Scheme/pyra.rb ...`.\n\nFor example, to compile and run the bubble-sort example:\n\n```sh\npsll -v compile ./examples/bubble_sort.psll -o && \\\nruby ./Pyramid-Scheme/pyra.rb ./examples/bubble_sort.pyra\n```\n\nYou can also run the pyramid schem straight from `psll` cli. For that to work, make sure `ruby` is in the path.\n\n```sh\npsll run ./examples/bubble_sort.pyra\n```\n\nThere is also a convenience command to compile a psll program in a temp directory and run it:\n\n```sh\npsll -v compile-and-run ./examples/bubble_sort.psll\n```\nHere it it specified with a `-v` option to also count the number of \n\n\n## \ud83d\udca1 Examples\n\nThe following is an example lisp-like pyramid scheme which counts the number of input arguments it gets, and then prints it out to the command line. The syntax supports `//` comments and newlines, as well as (almost) random additions of whitespace.\n\nFor the purposed of the markdown README, C# highlighting seems to look fine. There is a vscode extension in the `psll-lang` folder which provides syntax highlighting for both psll and Pyramid Scheme.\n\n```cs\n// Make nil by asking for the 999'th input argument\n(set nil (arg 999))\n\n// Count the number of input arguments - n\n(set nargin 0)\n(do cond (\n (set nargin (+ nargin 1))\n (set cond (! (= (arg nargin) nil)))\n))\n(set nargin (- nargin 1))\n\n(out \"nargin: \" nargin) // Print\n```\n\nIt can be compiled and run as follows:\n\n```sh\npython -m psll ./examples/nargin_counter.psll -o -f\nruby ./Pyramid-Scheme/pyra.rb ./exmaples/nargin_counter.pyra 4 3 5 2 4\n```\n\nor with the `compile-and-run`\n\n```sh\npsll compile-and-run ./examples/nargin_counter.psll 4 3 5 2 4\n```\n\nThe output is `nargin: 5`\n\n\n## \ud83e\uddec Additional features\n\nPsll implements a few bits of syntactic sugar, to make writing complicated pyramid schemes easier.\n\n\n### Bracket expansion\n\nA bracket with multiple subtrees will get automatically split into multiple size-2 subtrees which will, in turn, get prepended with the empty string, as described above. Hence, the following psll code:\n\n```cs\n(\n (out 1) (out 2) (out 3) (out 4) (out 5)\n)\n```\n\nwill get interpreted as:\n\n```cs\n(\n (\n ( // First pair\n (out 1) (out 2)\n )\n ( // Second pair\n (out 3) (out 4)\n )\n ) // One left\n (out 5)\n)\n```\n\nThe elements are taken from the list pairwise, and put into sub-lists recursively, until the root list has length of 2 or less. Because of order of subtree evaluation in pyramid scheme, this preserves the execution order. Note that arbitrary indentation, and mid-line comments are allowed.\n\nThis feature is useful, for example, for keeping tidy the body of a for-loop or an if-statement:\n\n```cs\n(set a 0) // Flip-flop\n(set N 10) (set j 0) // N of iteration and loop counter\n(loop (! (= j N)) (\n // Do some work...\n (out j (chr 32)) // Print j and space\n (out a (chr 10)) // Print a and newline\n (set a (! a)) // Flip a\n(set j (+ j 1))\n))\n```\n\n### Strings\n\nIn pyramid scheme, the strings have to be built manually. The string hello is:\n\n```cs\n(set a (+ (+ (+ (+ (chr 72) (chr 101)) (chr 108)) (chr 108)) (chr 111)))\n```\n\nPsll expands a string literal into such construct, so its enough to write:\n\n```cs\n(set a \"Hello\")\n```\n\nOnly `\"` can be used to create strings.\n\n### Def keyword\n\nPsll implements `def` as a special keyword. The syntax for `def` is: `(def x (...))`, where `x` can be any string (except `def`) and `(...)` is any bracket. From that point onwards, each occurrence of `x` or `(x)` is replaced by the bracket `(...)`. The `def` statement itself gets replaced by an empty pyramid (hence evaluates to 0). For example:\n\n```cs\n(def f (set a (! a))) // This becomes ()\n(f) // This becomes (set a (! a))\n```\n\n`def` can, therefore be used akin to a function definition:\n\n```cs\n(set a 0)\n(def incr (set a (+ a 1))) // Increment a\n(incr) // This now becomes (set a (+ a 1))\n(out \"a: \" a) (out (chr 10))\n```\n\nOnce defined, it is possible to redefine `def`'s in terms of themselves:\n\n```cs\n(def incr ( // Redefine 'incr' as itself + printing\n (incr)\n (out \"<incr> a: \" a)\n (out (chr 10)) // Newline\n))\n(incr) // This now does the original incr + print\n```\n\nDefs are active **within the scope in which they are declared**. Hence:\n\n```cs\n(def f (incr)) // 'f' is an alias for 'incr'\n(f) // This now behaves as 'incr'\n(\n (out \"entering scope\" (chr 10))\n (def f (out \"Vikings approaching!\" (chr 10))) // Redefine f within the scope\n (f f f) // Do 'f' 3 times\n (out \"leaving scope\" (chr 10))\n)\n(out \"a: \" a) (out (chr 10)) // But 'a' remains unchanged\n(f) // 'f' works the same way as before the scope\n(incr) // and 'incr' also works the same way\n```\n\nThe code above prints `Vikings approaching!` three times, as opposed to incrementing `a` three times, btu then goes back to incrementing after the scope. \n\nThe following is, for example, a *postfix* implementation of the modulo function:\n\n```cs\n(def mod (loop (<=> (<=> a b) -1) (set a (- a b)))) // Set a to mod(a,b)\n(set a 11) (set b 7) (mod)\n```\n\n\n### Command expansion\n\nThe `out` command of Pyramid Scheme allows for output of, at most, 2 variables. To output more, one needs to chain mutiple such `out` statements. In psll an out command with more than two inputs gets automatically expanded into such chain, such that:\n\n```cs\n(out a b)\n(out c d)\n(out e)\n```\n\ncan be written simply as:\n\n```cs\n(out a b c d e)\n```\n\nThe former might, however be preferable in certain contexts since it allows for comments on each part of the `out`.\n\nA _similar_ expansion will is also implemented for binary operators `+`, `*` as well as `-`, `/`, `^`, `=` and `<=>`, such that:\n\n```cs\n(+ 1 2 3 4) // This\n(out (+ (+ (+ 1 2) 3) 4) newline) // Becomes this\n```\n\nAddition and subtraction are commutative over the set of all possible inputs, and hence the exact order of operations does not matter. (This is not quite true. String multiplication overloads concatenation and that's not commutative). For a non-commutative operation, e.g. subtraction, the expansion order does matter. Hence:\n\n```cs\n(- 1 2 3 4) // This\n(- (- (- 1 2) 3) 4) // Does indeed expand into this\n```\n\nbut,\n\n```cs\n(1 2 3 4 -) // This\n(- 1 (- 2 (- 3 4))) // Expands to this instead\n```\n\nFor the binary operations listed above, they can be specified at the end of the bracket to perform a right-associative expansion.\n\nFor the sake of compatibility with non-expanded brackets, the following two are also allowed, and identical:\n\n```cs\n(- 1 2)\n(1 2 -)\n```\n(and, of course, the same for other binary operations, even the commutative ones)\n\n\n### Underscore keyword\n\nThe underscore `_` can be used to explicitly specify an empty slot where a pyramid could be. It is not particularly useful from the user point of view (maybe except for fine-tuning the position of the pyramids for code golf), but it is very helpful for the compiler. All the leaves are eventually terminated with `_`, and string expansion used the `_` keyword to help pack the code a bit better.\n\n\n## \ud83e\uddda\ud83c\udffb\u200d\u2640\ufe0f Code optimisation\n\nPsll compiler allows for some code optimisation. Optimising the code for speed would be, let's be honest with ourselves, a bit silly at this point. Psll optimisation attempts, therefore, to minimise number of bytes in the source code, such that the result can be used in [code golf challenges](https://codegolf.stackexchange.com/a/208938/68200).\n\n\n### Greedy optimisation\n\nAttempt to package each pair of root nodes in the abstract syntax tree. Insert an empty pyramid in the very first place which is beneficial (hence _greedy_). If all such places have been exhausted, try all teh possible insertions of a single pyramid.\n\nThis optimisation technique tends to result in tall pyramid scheme. It is very fast, and produces intermediate-quality results.\n\n\n### Considerate optimisation\n\nConsider all the possible places to either insert a single pyramid, or package two adjacent pyramids up to certain depth (10). Choose the most beneficial.\n\nThis optimisation technique tends to result in wide pyramid scheme. It is slower than the greedy optimisation, but very often results in a smaller pyramid scheme.\n",
"bugtrack_url": null,
"license": "MIT License Copyright (c) 2023 Marcin Konowalczyk 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.",
"summary": "Read the latest Real Python tutorials",
"version": "0.1.6",
"project_urls": {
"Homepage": "https://github.com/MarcinKonowalczyk/psll-lang"
},
"split_keywords": [
"compiler",
"macros",
"code-golf",
"pyramid-scheme",
"programming-language"
],
"urls": [
{
"comment_text": "",
"digests": {
"blake2b_256": "3a150fba7ca58b6be683fc164fced8140ab1cb5383a9010cc805f0f879cd6688",
"md5": "6a1ac99735bc4ad1e3525c156b43f207",
"sha256": "4fc5624854231c10c795d5a022994f70ba57e112898498dd69c9e51f535cc19e"
},
"downloads": -1,
"filename": "psll-0.1.6-py3-none-any.whl",
"has_sig": false,
"md5_digest": "6a1ac99735bc4ad1e3525c156b43f207",
"packagetype": "bdist_wheel",
"python_version": "py3",
"requires_python": ">=3.9",
"size": 25614,
"upload_time": "2024-03-18T11:45:08",
"upload_time_iso_8601": "2024-03-18T11:45:08.923078Z",
"url": "https://files.pythonhosted.org/packages/3a/15/0fba7ca58b6be683fc164fced8140ab1cb5383a9010cc805f0f879cd6688/psll-0.1.6-py3-none-any.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": "",
"digests": {
"blake2b_256": "e3a64aac05519d1fe973244e54316f53d40075462861d8ccca824da2751b698d",
"md5": "567b184398010e27cfbe74d7506b4e23",
"sha256": "326de24ce92177543b60839f789aa556f9f81514617d9a3d5b91c2cfe20246b5"
},
"downloads": -1,
"filename": "psll-0.1.6.tar.gz",
"has_sig": false,
"md5_digest": "567b184398010e27cfbe74d7506b4e23",
"packagetype": "sdist",
"python_version": "source",
"requires_python": ">=3.9",
"size": 35070,
"upload_time": "2024-03-18T11:45:10",
"upload_time_iso_8601": "2024-03-18T11:45:10.504209Z",
"url": "https://files.pythonhosted.org/packages/e3/a6/4aac05519d1fe973244e54316f53d40075462861d8ccca824da2751b698d/psll-0.1.6.tar.gz",
"yanked": false,
"yanked_reason": null
}
],
"upload_time": "2024-03-18 11:45:10",
"github": true,
"gitlab": false,
"bitbucket": false,
"codeberg": false,
"github_user": "MarcinKonowalczyk",
"github_project": "psll-lang",
"travis_ci": true,
"coveralls": true,
"github_actions": true,
"lcname": "psll"
}
