Skip to content

Commit a2b6d4c

Browse files
LogendeLogende
committed
more refactoring and improvements
1 parent f5f0254 commit a2b6d4c

27 files changed

Lines changed: 224 additions & 288 deletions

‎.github/workflows/build.yml‎

Lines changed: 3 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -31,7 +31,7 @@ jobs:
3131
- name: Test Node.js converter
3232
working-directory: schema-conversion-orchestrator/external_converters/node
3333
run: |
34-
echo '{"sourceFormat":"SHACL","targetFormat":"JsonSchema","schema":"test schema"}' > test.json
34+
echo '{"sourceLanguage":"SHACL","targetLanguage":"JsonSchema","schema":"test schema"}' > test.json
3535
node dist/index.js convert test.json
3636
node dist/index.js list
3737
@@ -69,7 +69,7 @@ jobs:
6969
- name: Test Java converter
7070
working-directory: schema-conversion-orchestrator/external_converters/java
7171
run: |
72-
echo '{"sourceFormat":"Xsd","targetFormat":"Dtd","schema":"test schema"}' > test.json
72+
echo '{"sourceLanguage":"Xsd","targetLanguage":"Dtd","schema":"test schema"}' > test.json
7373
java -jar converter.jar convert test.json
7474
java -jar converter.jar list
7575
@@ -148,7 +148,7 @@ jobs:
148148
# Test conversion (if converters are available)
149149
curl -f -X POST http://localhost:5002/convert \
150150
-H "Content-Type: application/json" \
151-
-d '{"sourceFormat":"SHACL","targetFormat":"JsonSchema","schema":"test schema"}' || echo "No SHACL->JsonSchema converter available"
151+
-d '{"sourceLanguage":"SHACL","targetLanguage":"JsonSchema","schema":"test schema"}' || echo "No SHACL->JsonSchema converter available"
152152
153153
# Kill Flask app
154154
kill $FLASK_PID

‎schema-conversion-orchestrator/ConvertersLinkMl.py‎

Lines changed: 10 additions & 10 deletions
Original file line numberDiff line numberDiff line change
@@ -24,13 +24,13 @@
2424

2525

2626
class ConverterFromLinkMl(ConverterInternal):
27-
def __init__(self, target_format: SchemaLanguage):
27+
def __init__(self, target_language: SchemaLanguage):
2828
super().__init__(
29-
name="LinkML " + target_format.name + " Generator",
29+
name="LinkML " + target_language.name + " Generator",
3030
service_address="internal",
3131
service_name="FlaskApp",
32-
source_format=SchemaLanguage.LinkMl,
33-
target_format=target_format,
32+
source_language=SchemaLanguage.LinkMl,
33+
target_language=target_language,
3434
)
3535

3636
def converter_logic(self, schema: str) -> str:
@@ -41,8 +41,8 @@ def converter_logic(self, schema: str) -> str:
4141

4242
schema_path = f.name
4343

44-
# Pick generator based on target format
45-
fmt = self.target_format
44+
# Pick generator based on target language
45+
fmt = self.target_language
4646

4747
gen_map: Dict[SchemaLanguage, Type[Generator]] = {
4848
SchemaLanguage.JsonSchema: JsonSchemaGenerator,
@@ -82,8 +82,8 @@ def __init__(self):
8282
name="LinkMl schema_automator JsonSchemaImportEngine",
8383
service_address="internal",
8484
service_name="FlaskApp",
85-
source_format=SchemaLanguage.JsonSchema,
86-
target_format=SchemaLanguage.LinkMl,
85+
source_language=SchemaLanguage.JsonSchema,
86+
target_language=SchemaLanguage.LinkMl,
8787
)
8888

8989
def converter_logic(self, schema: str) -> str:
@@ -121,8 +121,8 @@ def __init__(self):
121121
name="LinkMl schema_automator OwlImportEngine",
122122
service_address="internal",
123123
service_name="FlaskApp",
124-
source_format=SchemaLanguage.Owl,
125-
target_format=SchemaLanguage.LinkMl,
124+
source_language=SchemaLanguage.Owl,
125+
target_language=SchemaLanguage.LinkMl,
126126
)
127127

128128
def converter_logic(self, schema: str) -> str:

‎schema-conversion-orchestrator/ConvertersMdModels.py‎

Lines changed: 19 additions & 19 deletions
Original file line numberDiff line numberDiff line change
@@ -7,44 +7,44 @@
77

88

99
class ConverterFromMdModels(ConverterInternal):
10-
def __init__(self, target_format: SchemaLanguage):
10+
def __init__(self, target_language: SchemaLanguage):
1111
super().__init__(
12-
name="MdModels Templates: " + target_format.name,
12+
name="MdModels Templates: " + target_language.name,
1313
service_address="internal",
1414
service_name="FlaskApp",
15-
source_format=SchemaLanguage.MdModels,
16-
target_format=target_format,
15+
source_language=SchemaLanguage.MdModels,
16+
target_language=target_language,
1717
)
1818

1919
def converter_logic(self, schema: str) -> str:
2020
dm = DataModel.from_markdown_string(schema)
2121
try:
22-
if self.target_format == SchemaLanguage.Protobuf:
22+
if self.target_language == SchemaLanguage.Protobuf:
2323
return dm.convert_to(Templates.Protobuf)
24-
elif self.target_format == SchemaLanguage.Xsd:
24+
elif self.target_language == SchemaLanguage.Xsd:
2525
return dm.convert_to(Templates.XmlSchema)
26-
elif self.target_format == SchemaLanguage.PythonPydantic:
26+
elif self.target_language == SchemaLanguage.PythonPydantic:
2727
return dm.convert_to(Templates.PythonPydantic)
28-
elif self.target_format == SchemaLanguage.JsonSchema:
28+
elif self.target_language == SchemaLanguage.JsonSchema:
2929
return dm.convert_to(Templates.JsonSchema) # test difference with JsonSchemaAll
30-
elif self.target_format == SchemaLanguage.GraphQL:
30+
elif self.target_language == SchemaLanguage.GraphQL:
3131
return dm.convert_to(Templates.Graphql)
32-
elif self.target_format == SchemaLanguage.Julia_MdModels:
32+
elif self.target_language == SchemaLanguage.Julia_MdModels:
3333
return dm.convert_to(Templates.Julia)
34-
elif self.target_format == SchemaLanguage.Mermaid:
34+
elif self.target_language == SchemaLanguage.Mermaid:
3535
return dm.convert_to(Templates.Mermaid)
36-
elif self.target_format == SchemaLanguage.SHACL:
36+
elif self.target_language == SchemaLanguage.SHACL:
3737
return dm.convert_to(Templates.Shacl)
38-
elif self.target_format == SchemaLanguage.Rust_MdModels:
38+
elif self.target_language == SchemaLanguage.Rust_MdModels:
3939
return dm.convert_to(Templates.Rust)
40-
elif self.target_format == SchemaLanguage.TypeScript_MdModels:
40+
elif self.target_language == SchemaLanguage.TypeScript_MdModels:
4141
return dm.convert_to(Templates.Typescript)
42-
elif self.target_format == SchemaLanguage.Shex:
42+
elif self.target_language == SchemaLanguage.Shex:
4343
return dm.convert_to(Templates.Shex)
4444
else:
45-
raise ValueError(f"Unsupported target format: {self.target_format}")
45+
raise ValueError(f"Unsupported target format: {self.target_language}")
4646
except Exception as e:
47-
raise RuntimeError(f"Error during conversion to {self.target_format}: {str(e)}.")
47+
raise RuntimeError(f"Error during conversion to {self.target_language}: {str(e)}.")
4848

4949
def validate_input(self, schema: str) -> bool:
5050
# Implement validation logic for JSON Schema
@@ -61,8 +61,8 @@ def __init__(self):
6161
name="MdModels DataModel from JsonSchema",
6262
service_address="internal",
6363
service_name="FlaskApp",
64-
source_format=SchemaLanguage.JsonSchema,
65-
target_format=SchemaLanguage.MdModels,
64+
source_language=SchemaLanguage.JsonSchema,
65+
target_language=SchemaLanguage.MdModels,
6666
)
6767

6868
def converter_logic(self, schema: str) -> str:

‎schema-conversion-orchestrator/ConvertersXsd.py‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -11,8 +11,8 @@ def __init__(self):
1111
name="XmlSchema to JsonSchema Converter",
1212
service_address="internal",
1313
service_name="FlaskApp",
14-
source_format=SchemaLanguage.Xsd,
15-
target_format=SchemaLanguage.JsonSchema,
14+
source_language=SchemaLanguage.Xsd,
15+
target_language=SchemaLanguage.JsonSchema,
1616
)
1717

1818
def converter_logic(self, schema: str) -> str:

‎schema-conversion-orchestrator/app.py‎

Lines changed: 3 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -17,7 +17,7 @@
1717

1818
print("Started Schema Conversion Orchestrator with the following converters:")
1919
for conv in converters:
20-
print(f"- {conv.name}: {conv.source_format} -> {conv.target_format} at {conv.service_address}")
20+
print(f"- {conv.name}: {conv.source_language} -> {conv.target_language} at {conv.service_address}")
2121

2222

2323
@app.route("/health", methods=["GET"])
@@ -28,8 +28,8 @@ def health():
2828
@app.route("/convert", methods=["POST"])
2929
def convert():
3030
data = request.json
31-
source = data["sourceFormat"]
32-
target = data["targetFormat"]
31+
source = data["sourceLanguage"]
32+
target = data["targetLanguage"]
3333
schema = data["schema"]
3434

3535
try:

‎schema-conversion-orchestrator/conversion_strategies.py‎

Lines changed: 5 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -80,28 +80,28 @@ def attempt_conversion_path(source: str, target: str, path: List[Converter], sch
8080
# use cached result in case of cache hit and good previous conversion
8181
current_schema = cached_result
8282
print(
83-
"Using cached intermediate schema of format " + conv.target_format + " after conversion via " + conv.service_name + ": " + current_schema)
83+
"Using cached intermediate schema of format " + conv.target_language + " after conversion via " + conv.service_name + ": " + current_schema)
8484
continue
8585
else:
8686
# cache miss - perform conversion
8787
current_schema = conv.convert(current_schema)
8888
if DETAILED_RESULT_OUTPUT:
8989
print(
90-
"\n\nIntermediate schema of format " + conv.target_format + " after conversion via " + conv.service_name + ": \n" + current_schema + "\n\n\n\n")
90+
"\n\nIntermediate schema of format " + conv.target_language + " after conversion via " + conv.service_name + ": \n" + current_schema + "\n\n\n\n")
9191
# store in cache
9292
conversions_cache[conversion_sub_path_hash] = current_schema
9393

9494
return current_schema, conversions_cache
9595
except Exception as e:
9696
print(
97-
"Conversion failed at step from " + current_converter.source_format + " to " + current_converter.target_format + " via " + current_converter.service_name + " because of error: " + str(
97+
"Conversion failed at step from " + current_converter.source_language + " to " + current_converter.target_language + " via " + current_converter.service_name + " because of error: " + str(
9898
e) + ".")
9999
print("With intermediate schema: " + current_schema)
100100
raise Exception(
101-
f"Conversion failed at step from {current_converter.source_format} to {current_converter.target_format} via {current_converter.service_name} because of error: {str(e)}.")
101+
f"Conversion failed at step from {current_converter.source_language} to {current_converter.target_language} via {current_converter.service_name} because of error: {str(e)}.")
102102

103103

104104
def print_conversion_path(source: str, target: str, path: List[Converter]) -> None:
105105
print("Conversion path for source format '" + source + "' and target format '" + target + "':")
106106
for conv in path:
107-
print(f"- {conv.source_format} --({conv.name} ({conv.service_address})--> {conv.target_format})")
107+
print(f"- {conv.source_language} --({conv.name} ({conv.service_address})--> {conv.target_language})")

‎schema-conversion-orchestrator/converter.py‎

Lines changed: 27 additions & 28 deletions
Original file line numberDiff line numberDiff line change
@@ -12,46 +12,45 @@ class Converter:
1212
:param name: Name of the converter
1313
:param service_address: Address of the converter service or path to executable
1414
:param service_name: Name of the converter service
15-
:param source_format: Source schema language
16-
:param target_format: Target schema language
17-
:param supported_features: Dictionary mapping SchemaFeature to SchemaFeatureSupport or None if unknown
15+
:param source_language: Source schema language
16+
:param target_language: Target schema language
1817
"""
1918

20-
def __init__(self, name: str, service_address: str, service_name: str, source_format: SchemaLanguage,
21-
target_format: SchemaLanguage):
19+
def __init__(self, name: str, service_address: str, service_name: str, source_language: SchemaLanguage,
20+
target_language: SchemaLanguage):
2221
self.name = name
2322
self.service_address = service_address
2423
self.service_name = service_name
25-
self.source_format = source_format
26-
self.target_format = target_format
24+
self.source_language = source_language
25+
self.target_language = target_language
2726

2827
def convert(self, schema: str) -> str:
2928
raise NotImplementedError("This method should be overridden by subclasses")
3029

3130

3231
class ConverterExternal(Converter):
3332
"""
34-
External converter that calls a subprocess to perform conversion
33+
External converter that calls a subprocess to perform conversions
3534
:param name: Name of the converter
3635
:param executable_path: Path to the converter executable
3736
:param service_name: Name of the converter service
38-
:param source_format: Source schema language
39-
:param target_format: Target schema language
37+
:param source_language: Source schema language
38+
:param target_language: Target schema language
4039
"""
41-
def __init__(self, name: str, executable_path: str, service_name: str, source_format: SchemaLanguage,
42-
target_format: SchemaLanguage):
43-
super().__init__(name, executable_path, service_name, source_format, target_format)
40+
def __init__(self, name: str, executable_path: str, service_name: str, source_language: SchemaLanguage,
41+
target_language: SchemaLanguage):
42+
super().__init__(name, executable_path, service_name, source_language, target_language)
4443
self.executable_path = executable_path
4544

4645
def convert(self, schema: str) -> str:
4746
print(
48-
f"Calling external converter {self.name} at {self.executable_path} for {self.source_format} to {self.target_format}")
47+
f"Calling external converter {self.name} at {self.executable_path} for {self.source_language} to {self.target_language}")
4948

5049
# Create temporary files for input and output
5150
with tempfile.NamedTemporaryFile(mode='w', suffix='.json', delete=False) as input_file:
5251
input_data = {
53-
"sourceFormat": self.source_format.value,
54-
"targetFormat": self.target_format.value,
52+
"sourceLanguage": self.source_language.value,
53+
"targetLanguage": self.target_language.value,
5554
"converterName": self.name,
5655
"schema": schema
5756
}
@@ -90,12 +89,12 @@ class ConverterInternal(Converter):
9089
:param name: Name of the converter
9190
:param service_address: Address of the converter service or path to executable
9291
:param service_name: Name of the converter service
93-
:param source_format: Source schema language
94-
:param target_format: Target schema language
92+
:param source_language: Source schema language
93+
:param target_language: Target schema language
9594
"""
96-
def __init__(self, name: str, service_address: str, service_name: str, source_format: SchemaLanguage,
97-
target_format: SchemaLanguage):
98-
super().__init__(name, service_address, service_name, source_format, target_format)
95+
def __init__(self, name: str, service_address: str, service_name: str, source_language: SchemaLanguage,
96+
target_language: SchemaLanguage):
97+
super().__init__(name, service_address, service_name, source_language, target_language)
9998

10099
def convert(self, schema: str) -> str:
101100
if not self.validate_input(schema):
@@ -124,21 +123,21 @@ def validate_output(self, schema: str) -> bool:
124123
class ConverterExternalGeneric(ConverterExternal):
125124
"""Generic external converter that can handle multiple conversion types"""
126125

127-
def __init__(self, name: str, executable_path: str, source_format: SchemaLanguage,
128-
target_format: SchemaLanguage,
126+
def __init__(self, name: str, executable_path: str, source_language: SchemaLanguage,
127+
target_language: SchemaLanguage,
129128
converter_type: str):
130-
super().__init__(name, executable_path, converter_type, source_format, target_format)
129+
super().__init__(name, executable_path, converter_type, source_language, target_language)
131130
self.converter_type = converter_type
132131

133132
def convert(self, schema: str) -> str:
134133
print(
135-
f"Calling external {self.converter_type} converter {self.name} for {self.source_format} to {self.target_format}")
134+
f"Calling external {self.converter_type} converter {self.name} for {self.source_language} to {self.target_language}")
136135

137136
# Create temporary files for input and output
138137
with tempfile.NamedTemporaryFile(mode='w', suffix='.json', delete=False) as input_file:
139138
input_data = {
140-
"sourceFormat": self.source_format.value,
141-
"targetFormat": self.target_format.value,
139+
"sourceLanguage": self.source_language.value,
140+
"targetLanguage": self.target_language.value,
142141
"converterName": self.name,
143142
"schema": schema
144143
}
@@ -196,7 +195,7 @@ def convert(self, schema: str) -> str:
196195

197196

198197
def conversion_path_to_string(path: ConversionPath) -> str:
199-
return " -> ".join([f"{conv.source_format.value} to {conv.target_format.value} via {conv.service_name}" for conv in path])
198+
return " -> ".join([f"{conv.source_language.value} to {conv.target_language.value} via {conv.service_name}" for conv in path])
200199

201200

202201
def prepare_conversion_results_for_serializing(results: ConversionResults) -> dict:

0 commit comments

Comments
 (0)