add binary install feature&bump up

Author: thautwarm

purescripto/configure.py

@@ -128,10 +128,24 @@ def solve_ffi(conf: CValue, update_mirror: bool) -> Iterable[str]:
             yield solve_github_repo_url(package_name, version)
 
 
+FILES_TO_IGNORE = ['.pure-py/']
 def pspy(
     run: bool = False, version: bool = False, init: bool = False, update: bool = False
 ):
-    """PureScript Python compiler"""
+    """PureScript Python compiler
+    --run     : running without rebuild(note that `spago run` will rebuild the code)
+    --version : version of your purescript-python wrapper(purescripto)
+    --init    : setup purescript-python components for a spago project
+    --update  : sync with latest mirror and Python FFI dependencies
+
+example use:
+    Create a pspy project:
+        sh> mkdir purescript-xxx && cd purescript-xxx && spago init && pspy --init
+    Update project's dependencies:
+        sh> cd purescript-xxx && pspy --update
+    Build your project:
+        sh> pspy
+    """
     path = Path().absolute()
     pure_py_conf = path / "pure-py.json"
     py_pack_name_default = path.name.replace("-", "_")
@@ -142,9 +156,9 @@ def pspy(
 
             ignore_file = path / ".gitignore"
             with ignore_file.open("a+") as f:
-                is_configured = {".pure-py/": True, "pure-py.json": True}
+                is_configured = {k: True for k in FILES_TO_IGNORE}
                 for each in f.readlines():
-                    if each in (".pure-py/", "pure-py.json"):
+                    if each in FILES_TO_IGNORE:
                         is_configured[each] = False
 
                 xs = [k for k, v in is_configured.items() if v]

purescripto/installer.py

@@ -0,0 +1,126 @@
+import re
+import io
+import os
+import requests
+import zipfile
+import stat
+from pathlib import Path
+from distutils.util import get_platform
+
+tag = re.compile('refs/tags/v(\S+)')
+
+
+def make_executable(cmd_path):
+    # always modify mode to READ + EXEC
+    os.chmod(cmd_path, stat.S_IREAD | stat.S_IEXEC)
+
+
+def show_tags(url=r"https://github.com/purescript-python/purescript-python"):
+    """
+    Use ls-remote in gitPython
+    https://stackoverflow.com/questions/35585236/git-ls-remote-in-gitpython
+    """
+    import git
+    g = git.cmd.Git()
+    for ref in g.ls_remote(url).split('\n'):
+        found = tag.findall(ref.split('\t')[-1].strip())
+        if not found:
+            continue
+        yield found[0]
+
+
+def mk_tmplt(template):
+    if isinstance(template, dict):
+
+        def check(data,
+                  *,
+                  tmplt=tuple((k, mk_tmplt(v)) for k, v in template.items())):
+            if not isinstance(data, dict):
+                return False
+            for k, v in tmplt:
+                if k not in data:
+                    return False
+                if not v(data[k]):
+                    return False
+            return True
+
+    elif isinstance(template, list):
+
+        def check(data, *, tmplt=tuple(map(mk_tmplt, template))):
+            if not isinstance(data, list):
+                return False
+            if len(data) != len(tmplt):
+                return False
+            for t, v in zip(tmplt, data):
+                if not t(v):
+                    return False
+            return True
+
+    elif isinstance(template, type):
+
+        def check(data, *, t=template):
+            return isinstance(data, t)
+
+    elif template is any:
+        check = lambda _: True
+    elif hasattr(template, 'match'):
+        check = template.match
+    else:
+
+        def check(data, *, o=template):
+            return data == o
+
+    return check
+
+
+def traverse(f, data):
+    if isinstance(data, dict):
+        for each in data.values():
+            yield from traverse(f, each)
+    elif isinstance(data, list):
+        for each in data:
+            yield from traverse(f, each)
+    if f(data):
+        yield data
+
+
+def gq(tmp, data):
+    return traverse(mk_tmplt(tmp), data)
+
+def get_binary(out_path):
+    """out_path is the directory of executable, instead of the path
+    """
+    if isinstance(out_path, str):
+        out_path = Path(out_path)
+    elif not isinstance(out_path, Path):
+        raise TypeError(type(out_path))
+    from purescripto.version import __blueprint_version__
+    max_fit_tag = max(filter(lambda x: x.startswith(__blueprint_version__), show_tags()))
+
+    print('Downloading binaries from purescript-python/purescript-python...')
+    data = requests.get(
+        r"https://api.github.com/repos/purescript-python/purescript-python/releases/tags/v{}"
+        .format(max_fit_tag)).json()
+    print('Binaries downloaded.')
+    plat_name = get_platform()
+
+    matcher = re.compile('\S+' + re.escape(plat_name))
+    tmplt = {'browser_download_url': matcher}
+    try:
+        each = next(gq(tmplt, data))
+    except StopIteration:
+        import sys
+        print(
+            "It seems that binaries for your platform is not available.\n"
+            "Following way must work, but can be quite time-consuming:\n"
+            "Firstly, Install Haskell Stack Build Tool: https://docs.haskellstack.org/en/stable/README/\n"
+            "Second, Clone https://github.com/purescript-python/purescript-python, then do `stack install .`"
+        )
+        sys.exit(1)
+
+    url = each['browser_download_url']
+    zf = zipfile.ZipFile(io.BytesIO(requests.get(url).content))
+    exe = "pspy-blueprint.exe"
+    out_path.mkdir(exist_ok=True, parents=True, mode=0o777)
+    zf.extract(exe, path=str(out_path))
+    make_executable(str(out_path / exe))

purescripto/pspy.py

@@ -1,6 +1,20 @@
 from purescripto.configure import pspy
+from purescripto.installer import get_binary
+from purescripto.template_setup import gen_setup, gen_init
 
+def cmd_get_binary():
+    import wisepy2
+    wisepy2.wise(get_binary)()
+
+
+def cmd_gen_setup():
+    import wisepy2
+    wisepy2.wise(gen_setup)()
+
+def cmd_gen_init():
+    import wisepy2
+    wisepy2.wise(gen_init)()
 
-def main():
+def cmd_pspy():
     import wisepy2
-    wisepy2.wise(pspy)()
+    wisepy2.wise(pspy)()

purescripto/template_setup.py

@@ -0,0 +1,60 @@
+def gen_setup():
+    meta_setup = r"""
+import sys
+import os
+from setuptools import setup
+from pathlib import Path
+from purescripto.version import __version__
+readme = ''
+
+setup(
+    name='pspy-executable',
+    version=__version__,
+    keywords="",  # keywords of your project that separated by comma ","
+    description="",  # a concise introduction of your project
+    long_description=readme,
+    long_description_content_type="text/markdown",
+    license='mit',
+    python_requires='>=3.5.0',
+    url='https://github.com/purescript-python/installer',
+    author='thautawarm',
+    author_email='[email protected]',
+    packages=['pspy_executable'],
+    install_requires=[],
+    package_data={
+        'pspy_executable': [
+            each.name for each in Path('pspy_executable').iterdir()
+            if each.name.startswith('pspy')
+        ]
+    },
+    entry_points={"console_scripts": [
+        "pspy-blueprint=pspy_executable:exe",
+        "pspy-blueprint-check=pspy_executable:check"
+    ]},
+    platforms="any",
+    classifiers=[
+        "Programming Language :: Python :: 3.5",
+        "Programming Language :: Python :: 3.6",
+        "Programming Language :: Python :: 3.7",
+        "Programming Language :: Python :: 3.8",
+        "Programming Language :: Python :: 3.9",
+        "Programming Language :: Python :: Implementation :: CPython",
+    ],
+    zip_safe=False,
+)
+"""
+    print(meta_setup)
+
+def gen_init():
+    meta_init = r"""
+def exe():
+    from pathlib import Path
+    from subprocess import call
+    import sys
+    cmd = str((Path(__file__).parent / "pspy-blueprint.exe").absolute())
+    call([cmd, *sys.argv[1:]])
+
+def check():
+    print("pspy-executable installed")
+"""
+    print(meta_init)

purescripto/version.py

@@ -1,2 +1,2 @@
-__version__ = "0.8.4"
+__version__ = "0.8.5"
 __blueprint_version__ = '0.1.3'

setup.py

@@ -19,7 +19,14 @@
     author="thautawarm",
     author_email="[email protected]",
     packages=["purescripto"],
-    entry_points={"console_scripts": ["pspy=purescripto.pspy:main"]},
+    entry_points={
+        "console_scripts": [
+            "pspy=purescripto.pspy:cmd_pspy",
+            "pspy-get-binary=purescripto.pspy:cmd_get_binary",
+            "pspy-gen-setup=purescripto.pspy:cmd_gen_setup",
+            "pspy-gen-init=purescripto.pspy:cmd_gen_init",
+        ]
+    },
     # above option specifies what commands to install,
     # e.g: entry_points={"console_scripts": ["yapypy=yapypy.cmd:compiler"]}
     install_requires=[