catocli 1.0.1__py3-none-any.whl

schema/importSchema.py

@@ -0,0 +1,60 @@
+#!/usr/bin/python
+import catolib
+import logging
+import json
+
+############ ENV Settings ############
+logging.basicConfig(filename="download-schema.log", filemode='w', format='%(name)s - %(levelname)s - %(message)s')
+options = catolib.initParser()
+
+def run():
+	# ########################## OPTION 1 ##############################
+	# ## Uncomment this secion to build cli as one continuous job 
+	# ##################################################################
+	# query = {
+	# 	'query':'query IntrospectionQuery { __schema { description } }',
+	# 	'operationName':'IntrospectionQuery'
+	# }
+	# success,introspection = catolib.send(options.api_key,query)
+	# catolib.parseSchema(introspection)
+	# catolib.writeCliDriver(catolib.catoApiSchema)
+	# catolib.writeOperationParsers(catolib.catoApiSchema)
+	# catolib.writeReadmes(catolib.catoApiSchema)
+	# ##################################################################
+
+	######################### OPTION 2 ##############################
+	## Uncomment to manually run each step manually writing files locally 
+	######################### Step 1 ################################ 
+	## Run intrpsection to pull down schema and write locally
+	################################################################# 
+	query = {
+		'query':'query IntrospectionQuery { __schema { description } }',
+		'operationName':'IntrospectionQuery'
+	}
+	success,resp = catolib.send(options.api_key,query)
+	catolib.writeFile("introspection.json",json.dumps(resp, indent=4, sort_keys=True))
+	# ################################################################# 
+	
+	######################### Step 2 ################################ 
+	## Load from introsspeection from local file, and 
+	## use catolib to parse the schema, write locally 
+	## to catoApiIntrospection.json and catoApiSchema.json
+	################################################################# 
+	introspection = catolib.loadJSON("introspection.json")
+	catolib.parseSchema(introspection)
+	catolib.writeFile("catoApiIntrospection.json",json.dumps(catolib.catoApiIntrospection, indent=4, sort_keys=True))
+	catolib.writeFile("catoApiSchema.json",json.dumps(catolib.catoApiSchema, indent=4, sort_keys=True))
+	#################################################################      
+
+	####################### Step 3 ################################ 
+	## Load catoApiSchema from local file, and write cliDriver
+	## operation parsers, and readmes locally
+	#############################################################
+	catolib.catoApiSchema = catolib.loadJSON("catoApiSchema.json")
+	catolib.writeCliDriver(catolib.catoApiSchema)
+	catolib.writeOperationParsers(catolib.catoApiSchema)
+	catolib.writeReadmes(catolib.catoApiSchema)
+	###############################################################
+
+if __name__ == '__main__':
+	run()

vendor/certifi/__init__.py

@@ -0,0 +1,4 @@
+from .core import contents, where
+
+__all__ = ["contents", "where"]
+__version__ = "2024.08.30"

vendor/certifi/__main__.py

@@ -0,0 +1,12 @@
+import argparse
+
+from certifi import contents, where
+
+parser = argparse.ArgumentParser()
+parser.add_argument("-c", "--contents", action="store_true")
+args = parser.parse_args()
+
+if args.contents:
+    print(contents())
+else:
+    print(where())

vendor/certifi/core.py

@@ -0,0 +1,114 @@
+"""
+certifi.py
+~~~~~~~~~~
+
+This module returns the installation location of cacert.pem or its contents.
+"""
+import sys
+import atexit
+
+def exit_cacert_ctx() -> None:
+    _CACERT_CTX.__exit__(None, None, None)  # type: ignore[union-attr]
+
+
+if sys.version_info >= (3, 11):
+
+    from importlib.resources import as_file, files
+
+    _CACERT_CTX = None
+    _CACERT_PATH = None
+
+    def where() -> str:
+        # This is slightly terrible, but we want to delay extracting the file
+        # in cases where we're inside of a zipimport situation until someone
+        # actually calls where(), but we don't want to re-extract the file
+        # on every call of where(), so we'll do it once then store it in a
+        # global variable.
+        global _CACERT_CTX
+        global _CACERT_PATH
+        if _CACERT_PATH is None:
+            # This is slightly janky, the importlib.resources API wants you to
+            # manage the cleanup of this file, so it doesn't actually return a
+            # path, it returns a context manager that will give you the path
+            # when you enter it and will do any cleanup when you leave it. In
+            # the common case of not needing a temporary file, it will just
+            # return the file system location and the __exit__() is a no-op.
+            #
+            # We also have to hold onto the actual context manager, because
+            # it will do the cleanup whenever it gets garbage collected, so
+            # we will also store that at the global level as well.
+            _CACERT_CTX = as_file(files("certifi").joinpath("cacert.pem"))
+            _CACERT_PATH = str(_CACERT_CTX.__enter__())
+            atexit.register(exit_cacert_ctx)
+
+        return _CACERT_PATH
+
+    def contents() -> str:
+        return files("certifi").joinpath("cacert.pem").read_text(encoding="ascii")
+
+elif sys.version_info >= (3, 7):
+
+    from importlib.resources import path as get_path, read_text
+
+    _CACERT_CTX = None
+    _CACERT_PATH = None
+
+    def where() -> str:
+        # This is slightly terrible, but we want to delay extracting the
+        # file in cases where we're inside of a zipimport situation until
+        # someone actually calls where(), but we don't want to re-extract
+        # the file on every call of where(), so we'll do it once then store
+        # it in a global variable.
+        global _CACERT_CTX
+        global _CACERT_PATH
+        if _CACERT_PATH is None:
+            # This is slightly janky, the importlib.resources API wants you
+            # to manage the cleanup of this file, so it doesn't actually
+            # return a path, it returns a context manager that will give
+            # you the path when you enter it and will do any cleanup when
+            # you leave it. In the common case of not needing a temporary
+            # file, it will just return the file system location and the
+            # __exit__() is a no-op.
+            #
+            # We also have to hold onto the actual context manager, because
+            # it will do the cleanup whenever it gets garbage collected, so
+            # we will also store that at the global level as well.
+            _CACERT_CTX = get_path("certifi", "cacert.pem")
+            _CACERT_PATH = str(_CACERT_CTX.__enter__())
+            atexit.register(exit_cacert_ctx)
+
+        return _CACERT_PATH
+
+    def contents() -> str:
+        return read_text("certifi", "cacert.pem", encoding="ascii")
+
+else:
+    import os
+    import types
+    from typing import Union
+
+    Package = Union[types.ModuleType, str]
+    Resource = Union[str, "os.PathLike"]
+
+    # This fallback will work for Python versions prior to 3.7 that lack the
+    # importlib.resources module but relies on the existing `where` function
+    # so won't address issues with environments like PyOxidizer that don't set
+    # __file__ on modules.
+    def read_text(
+        package: Package,
+        resource: Resource,
+        encoding: str = 'utf-8',
+        errors: str = 'strict'
+    ) -> str:
+        with open(where(), encoding=encoding) as data:
+            return data.read()
+
+    # If we don't have importlib.resources, then we will just do the old logic
+    # of assuming we're on the filesystem and munge the path directly.
+    def where() -> str:
+        f = os.path.dirname(__file__)
+
+        return os.path.join(f, "cacert.pem")
+
+    def contents() -> str:
+        return read_text("certifi", "cacert.pem", encoding="ascii")