def parse_bpmn(
bpmn_path: str, json_path: str, template_path: str, model_path: str
) -> None:
"""
this method reads from a given (camunda-modeler) bpmn/xml file and
completes a given skeleton template by initialized blocks and
their connections
"""
bpmn = _to_json_dict(bpmn_path, json_path)
elements = {
value: _get_elements_of_type(bpmn, key) for key, value in MAPPING.items()
}
components = _get_components_from_elements(elements)
_add_class_and_id_names(components + elements["resources"])
insertions = _generate_insertions(bpmn, elements, components)
model_components = _generate_model_components(components)
model_graph_names = _generate_model_graph_names(elements, components)
_write_model_file(
model_path, template_path, insertions, model_components, model_graph_names
)
path = pathlib.Path(model_path)
file_mode = black.FileMode()
black.format_file_in_place(path, False, file_mode, write_back=black.WriteBack.YES)
print("\nBPMN parsed.\n")
def _format_with_black(output_file_name):
black.format_file_in_place(
Path(output_file_name),
mode=black.FileMode(line_length=110),
fast=False,
write_back=black.WriteBack.YES,
)
def _code_style(dir: Path) -> None:
for file in dir.rglob('**/*.py'):
black.format_file_in_place(
src=file.absolute(),
fast=False,
mode=black.Mode(line_length=100,
target_versions={black.TargetVersion.PY38}),
write_back=black.WriteBack.YES)
def format(path):
black.format_file_in_place(
src=path,
fast=False,
mode=black.Mode(target_versions={black.TargetVersion.PY38}),
write_back=black.WriteBack.YES,
)
isort.file(path)
def cmd_black(*args, **kwargs):
import black
if args:
editedfile = Path(args[0])
black.format_file_in_place(
editedfile, fast=True, mode=black.FileMode(), write_back=black.WriteBack(1)
)
else:
runCommand("python -m black src tests")
def write_model(self):
app = apps.get_app_config(self.app_name)
file_path = Path(app.models_module.__file__)
with file_path.open("a") as model_file:
model_file.write(f"\n\n{self.render()}")
# Format file with black to make stuff nicer (a.k.a. I'm lazy)
format_file_in_place(file_path,
fast=False,
mode=FileMode(),
write_back=WriteBack.YES)
def cmd_black(*args, **kwargs):
import black
if args:
editedfile = Path(args[0])
print(f"##### black formatting {editedfile} #####")
black.format_file_in_place(
editedfile, fast=True, mode=black.FileMode(), write_back=black.WriteBack(1)
)
else:
runCommand(f"python -m black {PACKAGE_NAME} tests")
def format_file(filename):
try:
import black
black.format_file_in_place(
pathlib.Path(filename).absolute(),
88, # black default line length is 88
fast=True,
write_back=black.WriteBack.YES,
)
except:
pass
def create_dag_file(self, workflow: Workflow):
"""
Writes to a file the Apache Oozie parsed workflow in Airflow's DAG format.
"""
file_name = self.output_dag_name
with open(file_name, "w") as file:
logging.info(f"Saving to file: {file_name}")
dag_content = self.render_workflow(workflow)
file.write(dag_content)
black.format_file_in_place(Path(file_name),
mode=black.FileMode(line_length=110),
fast=False,
write_back=black.WriteBack.YES)
def format_blueprint_command(bp_file):
path = pathlib.Path(bp_file)
LOG.debug("Formatting blueprint {} using black".format(path))
if format_file_in_place(
path, fast=False, mode=FileMode(), write_back=WriteBack.DIFF
):
LOG.info("Patching above diff to blueprint - {}".format(path))
format_file_in_place(
path, fast=False, mode=FileMode(), write_back=WriteBack.YES
)
LOG.info("All done!")
else:
LOG.info("Blueprint {} left unchanged.".format(path))
def handler(event, context):
if "body" in event and event["body"]:
params = json.loads(event["body"])
else:
params = event
try:
git_repo = params["git_repo"]
git_branch = params[
"git_branch"] if "git_branch" in params else "master"
except KeyError:
return {
"body": json.dumps({"message": "git_repo is not provided"}),
"headers": {
"Content-Type": "application/json"
},
"statusCode": 401,
}
try:
r = requests.get(f"{git_repo}/archive/{git_branch}.zip")
open(f"{LOCAL_PATH}/{git_branch}.zip", 'wb').write(r.content)
with ZipFile(f"{LOCAL_PATH}/{git_branch}.zip", "r") as zipObj:
zipObj.extractall(f"{LOCAL_PATH}")
for root, dirs, files in os.walk(LOCAL_PATH):
for file in files:
if file.endswith(".py"):
format_file_in_place(Path(f"{root}/{file}"), False,
FileMode(), WriteBack.DIFF)
return {
"body": {
"message": "result in logs"
},
"headers": {
"Content-Type": "application/json"
},
"statusCode": 200,
}
except Exception as e:
message = e.message if hasattr(e, 'message') else e
return {
"body": {
"message": message
},
"headers": {
"Content-Type": "application/json"
},
"statusCode": 200,
}
def format_python_file(filename):
try:
import black
black.format_file_in_place(
pathlib.Path(filename).absolute(),
fast=True,
mode=black.FileMode(
line_length=88, target_versions={black.TargetVersion.PY33}
),
write_back=black.WriteBack.YES,
)
except:
pass
def test_black(self):
for p in self.files:
not_changed = black.format_file_in_place(p, False,
black.FileMode(),
black.WriteBack.NO)
self.assertFalse(not_changed,
"Found files not formatted by Black.")
def _run_black(self):
has_change = False
if not self._migration._use_black:
return
file_mode = black.FileMode()
file_mode.line_length = _BLACK_LINE_LENGTH
for root, directories, filenames in os.walk(
self._module_path.resolve()):
for filename in filenames:
# Skip useless file
if os.path.splitext(filename)[1] != ".py":
continue
absolute_file_path = os.path.join(root, filename)
has_change = has_change or black.format_file_in_place(
pathlib.Path(absolute_file_path), False, file_mode,
black.WriteBack.YES)
# Commit changes
if has_change:
commit_name = "[REF] %s: Black python code" % (self._module_name)
logger.info("Commit changes for %s. commit name '%s'" %
(self._module_name, commit_name))
_execute_shell(
"cd %s && git add . --all && git commit -m '%s'" %
(str(self._migration._directory_path.resolve()), commit_name))
def handle(self, *args, **options):
root = pathlib.Path(settings.BASE_DIR)
g_args = ["--exclude-standard", "-X", root.joinpath(".lintignore")]
if not options["all"]:
g_args.append("-m")
files_str = git.Git(settings.BASE_DIR).ls_files(g_args)
del_files_str = git.Git(settings.BASE_DIR).ls_files("-d", "-k")
files = set(
pathlib.Path(p)
for p in files_str.splitlines() if p[-3:] == ".py") - set(
pathlib.Path(p) for p in del_files_str.splitlines())
num_lint_errors = 0
num_black_formats = 0
for p in files:
if not options["no_fix"]:
changed = black.format_file_in_place(p, False,
black.FileMode(),
black.WriteBack.YES)
if changed:
num_black_formats += 1
self.stdout.write("%s: Black formatted file" % str(p))
if not options["no_lint"]:
num_lint_errors += pyflakes.checkPath(str(p))
if num_black_formats:
raise CommandError("%i file(s) formatted by Black" %
num_black_formats)
if num_lint_errors:
raise CommandError("%i liniting error(s) found" % num_lint_errors)
def black_reformat(source_path: Path) -> bool:
return black.format_file_in_place(
source_path,
fast=False,
mode=black.FileMode(),
write_back=black.WriteBack.YES,
)
def format_file(file: str) -> None:
file_path = Path(file)
if file_path.suffix in PYTHON_FILE_EXTENSIONS:
mode = black.FileMode(
target_versions={black.TargetVersion.PY38},
line_length=LINE_LENGTH,
is_pyi=file_path.suffix == ".pyi",
string_normalization=True,
)
isort.SortImports(file_path)
black.format_file_in_place(file_path, False, mode, black.WriteBack.YES)
elif file_path.suffix in CXX_FILE_EXTENSIONS:
subprocess.run(["clang-format", "-i", "-style=file", file_path],
cwd=WORKSPACE)
elif file_path.suffix == ".bzl" or file_path.name in {
"BUILD", "WORKSPACE"
}:
subprocess.run([BUILDIFIER, "-lint", "fix", file_path], cwd=WORKSPACE)
def _run_black(self):
if not self._migration._use_black:
return
file_mode = black.FileMode()
file_mode.line_length = _BLACK_LINE_LENGTH
for root, directories, filenames in os.walk(
self._module_path.resolve()):
for filename in filenames:
# Skip useless file
if os.path.splitext(filename)[1] != ".py":
continue
absolute_file_path = os.path.join(root, filename)
black.format_file_in_place(pathlib.Path(absolute_file_path),
False, file_mode,
black.WriteBack.YES)
def main():
with open(output_path, "w") as fd:
fd.write("# autogenerated by %s\n" % __file__)
fd.write("import re\n")
print("build backend_url_patterns")
index = build_backend_url_pattern_index()
with open(output_path, "a") as fd:
fd.write("backend_url_patterns = ")
pprint.pprint(index, fd)
fd.write(os.linesep)
print("format with black")
black.format_file_in_place(
Path(output_path),
fast=False,
mode=black.FileMode(),
write_back=black.WriteBack.YES,
)
def format_file(file: str, isortconfig: isort.settings.Config) -> None:
"""
Formats the given file using black.
:param file:
The file to format.
:parm isortconfig:
The configuration to apply while sorting the imports.
"""
isort.api.sort_file(pathlib.Path(file), config=isortconfig)
black.format_file_in_place(
pathlib.Path(file),
fast=False,
mode=black.Mode(),
write_back=black.WriteBack.YES,
)
PyFunceble.facility.Logger.info("Update format of %r", file)
def cleanup_code():
"""
Clean up all files of a given extension under a directory
"""
for filepath in glob.iglob("**/*.py", recursive=True):
path = pathlib.Path(os.getcwd(), filepath)
if black.format_file_in_place(path, False, black.FileMode(),
black.WriteBack.YES):
print("Formatted file: ", filepath)
else:
print(f"Skipping file {filepath} as it is already formatted")
def format_all_files(top_directory: pathlib.Path) -> None:
for file_dir, _, files in os.walk(top_dir):
for file in files:
file = pathlib.Path(file_dir) / file
if file.suffix != ".py":
continue
if black.format_file_in_place(file,
fast=True,
mode=black.FileMode(),
write_back=black.WriteBack.YES):
print(f"Reformatted {file}")
def _format_py_file(target: Path):
black.format_file_in_place(target,
fast=False,
mode=black.FileMode(),
write_back=WriteBack.YES)
def main(event, context):
print(" Starting LambdaOpt backend")
print(
"\n███████╗ █████╗ ██████╗ ██████╗ ██████╗ ████████╗\n██╔════╝██╔══██╗██╔══██╗██╔═══██╗██╔══██╗╚══██╔══╝\n█████╗ ███████║██████╔╝██║ ██║██████╔╝ ██║ \n██╔══╝ ██╔══██║██╔══██╗██║ ██║██╔═══╝ ██║ \n██║ ██║ ██║██║ ██║╚██████╔╝██║ ██║ \n╚═╝ ╚═╝ ╚═╝╚═╝ ╚═╝ ╚═════╝ ╚═╝ ╚═╝ \n\n"
)
print("---------------------------------------------------------------")
print('Downloading source')
print('Looking for source.zip in ', event['s3bucket'], '/',
event['s3key'] + '/source.zip')
s3 = boto3.client('s3')
try:
s3.download_file(event['s3bucket'], event['s3key'] + '/source.zip',
'/tmp/source.zip')
print('Downloaded source.zip! uncompressing')
except:
print('Could not download source. Please check :', event['s3bucket'],
'/', event['s3key'] + '/source.zip')
print("Setting env variables for micro environment")
os.environ['s3key'] = event['s3key']
os.environ['s3bucket'] = event['s3bucket']
with zipfile.ZipFile('/tmp/source.zip', 'r') as zip_ref:
zip_ref.extractall('/tmp/')
print("---------------------------------------------------------------")
# Add utils file
f = open("/var/task/utils.py", 'r')
utilsstr = f.read()
f.close()
# Rewrite to tmp
f = open("/tmp/utils.py", 'w')
f.write(utilsstr)
f.close()
listfiles = os.listdir("/tmp/")
print("reformatting with black")
for f in listfiles:
if f[-2:] == 'py':
print(f)
format_file_in_place(src=Path('/tmp/' + f),
fast=True,
mode=FileMode())
os.environ["PYTHONPATH"] = "/opt/python/lib/python3.7/site-packages"
process = subprocess.Popen([sys.executable, "/tmp/main.py"],
env=os.environ,
stdin=subprocess.PIPE,
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT)
output, error = process.communicate()
print(output.decode())
print("----")
print(error)
return {'statusCode': 200, 'body': json.dumps({'error': error})}
def test_unparseable_notebook() -> None:
path = DATA_DIR / "notebook_which_cant_be_parsed.ipynb"
msg = rf"File '{re.escape(str(path))}' cannot be parsed as valid Jupyter notebook\."
with pytest.raises(ValueError, match=msg):
format_file_in_place(path, fast=True, mode=JUPYTER_MODE)
def _format_code(self, py_filename):
_dargs = dict(fast=False, mode=black.FileMode(), write_back=black.WriteBack.YES)
assert black.format_file_in_place(pathlib.Path(py_filename), **_dargs), py_filename
]
)
# Needs to define the MVariant and GameFeatureType type:
writer._print("MoVariant = {}".format(Type.MO_VARIANT))
writer._print('GameFeatureType = TypeVar("GameFeatureType")')
writer._print()
# This is a class to represent interface not implemented:
writer.print_class(Class("InterfaceNotImplemented", [], []))
writer._print()
for n, o in objects:
# Get the corresponding object:
c = MOBASE_REGISTER.get_object(n)
if isinstance(c, Class):
writer.print_class(c)
elif isinstance(c, list) and isinstance(c[0], Function):
for fn in c:
writer.print_function(fn)
black.format_file_in_place(
args.output,
fast=False,
mode=black.Mode(is_pyi=args.output.name.endswith("pyi")),
write_back=black.WriteBack.YES,
)
from pathlib import Path
import sys
import black
output = Path(sys.argv[2])
output.mkdir(exist_ok=True)
for py in Path(sys.argv[1]).rglob("*.py"):
print(py)
content = Parser(py.open(), inline=False, module_name=py.name)
output_file = output / f"test_{py.name}"
with output_file.open("w") as fp:
for i, block in enumerate(content.parse().content):
if isinstance(block, Python):
fp.write(str(block))
fp.write("\n\n")
if isinstance(block, Docstring):
fp.write(f"def test_block_{i:000d}():\n")
for line in block.content:
fp.write(" " * 4 + line)
fp.write(' """\n pass\n\n')
black.format_file_in_place(
output_file, fast=True, mode=black.FileMode(), write_back=black.WriteBack.YES
)
writer.write("\n")
writer.write(" def accept(self, visitor):\n")
writer.write(f" return visitor.visit{className}{baseName}(self)\n")
writer.write("\n\n")
if __name__ == "__main__":
main()
p = pathlib.Path(__file__).resolve().parent.parent / "expr.py"
print(p)
print(
black.format_file_in_place(
src=p,
fast=False,
mode=black.Mode(target_versions={black.TargetVersion.PY38}),
write_back=black.WriteBack.YES,
))
print(isort.file(p))
p = pathlib.Path(__file__).resolve().parent.parent / "stmt.py"
print(p)
print(
black.format_file_in_place(
src=p,
fast=False,
mode=black.Mode(target_versions={black.TargetVersion.PY38}),
write_back=black.WriteBack.YES,
))
print(isort.file(p))
