சூபிட்டர் மற்றும் ச்கிரிப்டிங்

மாடல்களுடன் பணிபுரிய ஒரு வழி GUI வழியாகும். இருப்பினும், பைதான் ச்கிரிப்டுகள் மற்றும் சூபிட்டர் நோட்புக்குகள் மூலம் அவர்களுடன் தொடர்புகொள்வதன் மூலம் உங்கள் மாடல்களில் இருந்து அதிகம் வெளியேறவும் நீங்கள் ஆர்வமாக இருக்கலாம்.

நீங்கள் இதற்கு ச்கிரிப்ட்களைப் பயன்படுத்தலாம்:

• மாதிரியை ஆராய்ந்து, செல்லுபடியாகும் நிபந்தனைகளை சரிபார்க்கவும்.

• காஃபரின் தரவு மாதிரிக்காக செய்யப்படுவது போல குறியீட்டை உருவாக்குங்கள்.

• சி.எச்.வி கோப்பு போன்ற மற்றொரு மூலத்திலிருந்து ஒரு மாதிரியைப் புதுப்பிக்கவும்.

கஃபர் பைத்தானில் எழுதப்பட்டிருப்பதால், இது ஒரு நூலகமாகவும் செயல்படுகிறது.

தொடங்குதல்

தொடங்குவதற்கு, உங்களுக்கு பைதான் கன்சோல் தேவை. நீங்கள் கஃபரில் ஊடாடும் கன்சோலைப் பயன்படுத்தலாம், சூபிட்டர் நோட்புக்கைப் பயன்படுத்தலாம், இருப்பினும் இது பைதான் மேம்பாட்டு சூழலை அமைக்க வேண்டும்.

ஒரு மாதிரியை வினவவும்

முதல் படி ஒரு மாதிரியை ஏற்றுவது. இதற்காக உங்களுக்கு gaphor.core.modeling.ElementFactory தேவை. மாதிரியை உருவாக்குவதற்கும் பராமரிப்பதற்கும் ElementFactory பொறுப்பு. நீங்கள் பணிபுரியும் போது இது மாதிரிக்கான களஞ்சியமாக செயல்படுகிறது.

from gaphor.core.modeling import ElementFactory

element_factory = ElementFactory()

gaphor.storage தொகுதி மாதிரிகளை ஏற்றவும் சேமிக்கவும் எல்லாவற்றையும் கொண்டுள்ளது. கஃபர் பல மாடலிங் மொழிகள் ஐ ஆதரிக்கிறது. ModelingLanguageService அந்த மொழிகளை ஒருங்கிணைத்து, ஏற்றி தர்க்கத்திற்கு பொருத்தமான வகுப்புகளைக் கண்டுபிடிப்பதை எளிதாக்குகிறது.

Note

2.13 க்கு முந்தைய பதிப்புகளில், ஒரு நிகழ்வு மேலாளர் தேவை. பிற்கால பதிப்புகளில், மாடலிங் லாங்குவேச் சர்வீச் நிகழ்வு மேலாளர் இல்லாமல் துவக்கப்படலாம்.

from gaphor.core.eventmanager import EventManager
from gaphor.services.modelinglanguage import ModelingLanguageService
from gaphor.storage import storage

event_manager = EventManager()

modeling_language = ModelingLanguageService(event_manager=event_manager)

with open("../models/Core.gaphor", encoding="utf-8") as file_obj:
    storage.load(
        file_obj,
        element_factory,
        modeling_language,
    )

இந்த கட்டத்தில் மாதிரி உறுப்பு_பாக்டரி இல் ஏற்றப்பட்டு வினவப்படலாம்.

Note

ஒரு மாடலிங் மொழி மாதிரி கூறுகள் மற்றும் வரைபட உருப்படிகளைக் கொண்டுள்ளது. வரைகலை கூறுகள் தனித்தனியாக ஏற்றப்படுகின்றன. மிக அடிப்படையான மேனபிலேசன்களுக்கு, சி.டி.கே (நாங்கள் பயன்படுத்தும் சி.யு.ஐ கருவித்தொகுப்பு) தேவையில்லை, ஆனால் நீங்கள் சி.டி.கே நூலகத்தை ஏற்ற முயற்சிக்கும் சூழ்நிலைகளுக்கு நீங்கள் ஓடலாம்.

இதைத் தவிர்ப்பதற்கான ஒரு தந்திரம் (குறைந்த பட்சம் சூரரிமாச்சிலை டாக்சை உருவாக்கும் போது) சி.டி.கே மற்றும் சி.டி.கே நூலகங்களை கேலி செய்ய ஆட்டோடோக்கின் போலி செயல்பாட்டைப் பயன்படுத்துவது. இருப்பினும், உரை ரெண்டரிங்கிற்கு பாங்கோ நிறுவப்பட வேண்டும்.

ஒரு எளிய வினவல் மாதிரியில் என்ன கூறுகள் உள்ளன என்பதை மட்டுமே உங்களுக்குக் கூறுகிறது. Elielagefactory.select () ஒரு மறுசீரமைப்பாளரைத் தருகிறது. சில நேரங்களில் ஒரு பட்டியலை நேரடியாகப் பெறுவது எளிது. அந்த நிகழ்வுகளுக்கு நீங்கள் ElementFatory.lselect () ஐப் பயன்படுத்தலாம். இங்கே கடைசி ஐந்து கூறுகளைத் தேர்ந்தெடுக்கிறோம்:

for element in element_factory.lselect()[:5]:
    print(element)

<gaphor.UML.uml.Package element 3867dda4-7a95-11ea-a112-7f953848cf85>
<gaphor.UML.uml.Diagram element 3867dda5-7a95-11ea-a112-7f953848cf85>
<gaphor.UML.classes.klass.ClassItem element 5cdae47f-7a95-11ea-a112-7f953848cf85>
<gaphor.UML.classes.klass.ClassItem element 639b48d1-7a95-11ea-a112-7f953848cf85>
<gaphor.UML.classes.association.AssociationItem element 68e63fac-7a95-11ea-a112-7f953848cf85>

கூறுகளை வகை மற்றும் முன்கணிப்பு செயல்பாட்டுடன் வினவலாம்:

from gaphor import UML
for element in element_factory.select(UML.Class):
    print(element.name)

Diagram
Presentation
StyleSheet
Property
Tagged
ElementChange
ValueChange
RefChange
PendingChange
Base

for diagram in element_factory.select(
    lambda e: isinstance(e, UML.Class) and e.name == "Diagram"
):
    print(diagram)

<gaphor.UML.uml.Class element 5cdae47e-7a95-11ea-a112-7f953848cf85>

இப்போது, சில எளிய (போலி-) குறியீடு உருவாக்கம் செய்ய விரும்புகிறோம் என்று சொல்லலாம். நாம் வர்க்க பண்புகளை மீண்டும் உருவாக்கலாம் மற்றும் சில வெளியீட்டை எழுதலாம்.

diagram: UML.Class

def qname(element):
    return ".".join(element.qualifiedName)

diagram = next(element_factory.select(lambda e: isinstance(e, UML.Class) and e.name == "Diagram"))

print(f"class {diagram.name}({', '.join(qname(g) for g in diagram.general)}):")
for attribute in diagram.attribute:
    if attribute.typeValue:
        # Simple attribute
        print(f"    {attribute.name}: {attribute.typeValue}")
    elif attribute.type:
        # Association
        print(f"    {attribute.name}: {qname(attribute.type)}")

class Diagram(Root.Base):
    diagramType: String
    ownedPresentation: Presentation.Presentation

எந்த உறவுகளை வினவ முடியும் என்பதை அறிய, மாடலிங் மொழி ஆவணங்களைப் பாருங்கள். யுஎம்எல் மொழியைப் பயன்படுத்தி கஃபரின் தரவு மாதிரிகள் கட்டப்பட்டுள்ளன.

ஒரு மாதிரி சொத்தை அச்சிடுவதன் மூலம் அதை மேலும் அறியலாம்.

print(UML.Class.ownedAttribute)

<redefine ownedAttribute[0..*]: Property = <association ownedAttribute: Property[0..*] <>-> structuredClassifier>>

இந்த விசயத்தில் uml.class.ownedattribute வகை uml.property என்று அது நமக்கு சொல்கிறது. சொந்தமாக சொந்தமானவர் அமைக்கப்படும்போது uml.property.class_ உரிமையாளர் வகுப்பிற்கு அமைக்கப்பட்டுள்ளது. இது ஒரு இருதரப்பு உறவு.

ஒரு வரைபடத்தை வரையவும்

மற்றொரு நல்ல நற்பொருத்தம் வரைபடங்களை வரைவது. இந்த நேரத்தில் இதற்கு ஒரு செயல்பாடு தேவை. இந்த நடத்தை வரைபடம் டைரெக்டிவ் க்கு ஒத்ததாகும்.

from gaphor.core.modeling import Diagram
from gaphor.extensions.ipython import draw

d = next(element_factory.select(Diagram))
draw(d, format="svg")

ஒரு வரைபடத்தை உருவாக்கவும்

(காஃபர் 2.13 தேவை)

இப்போது இன்னும் கொஞ்சம் ஆடம்பரமான ஒன்றை உருவாக்குவோம். உறுப்பு தொழிற்சாலையில் இன்னும் முக்கிய மாதிரி ஏற்றப்பட்டுள்ளது. இந்த மாதிரியிலிருந்து தனிப்பயன் வரைபடத்தை உருவாக்கலாம். ஆட்டோ லேஅவுட் சேவையின் சிறிய உதவியுடன், அதை படிக்கக்கூடிய வரைபடமாக மாற்றலாம்.

வரைபடத்தை உருவாக்க, வரைபடத்தில் டிராப் கூறுகளை கைவிடுதல்). ஒரு வரைபடத்தில் உள்ள உருப்படிகள் மாதிரியில் உள்ள ஒரு உறுப்பைக் குறிக்கின்றன. எல்லா சங்கங்களையும் மாதிரியில் கைவிடுவோம். இரு முனைகளும் இணைக்க முடிந்தால் மட்டுமே, சங்கம் சேர்க்கப்படும்.

from gaphor.diagram.drop import drop
from gaphor.extensions.ipython import auto_layout

temp_diagram = element_factory.create(Diagram)

for name in ["Presentation", "Diagram", "Base"]:
    element = next(element_factory.select(
        lambda e: isinstance(e, UML.Class) and e.name == name
    ))
    drop(element, temp_diagram, x=0, y=0)

# Drop all assocations, see what sticks
for association in element_factory.lselect(UML.Association):
    drop(association, temp_diagram, x=0, y=0)

auto_layout(temp_diagram)

draw(temp_diagram, format="svg")

வரைபடம் சரியானதல்ல, ஆனால் நீங்கள் படத்தைப் பெறுவீர்கள்.

ஒரு மாதிரியைப் புதுப்பிக்கவும்

ஒரு மாதிரியைப் புதுப்பிப்பது எப்போதும் உறுப்பு தொழிற்சாலையுடன் தொடங்குகிறது: அங்குதான் கூறுகள் உருவாக்கப்படுகின்றன.

யுஎம்எல் வகுப்பு நிகழ்வை உருவாக்க, உங்களால் முடியும்:

my_class = element_factory.create(UML.Class)
my_class.name = "MyClass"

அதற்கு ஒரு பண்புக்கூறு கொடுக்க, ஒரு பண்புக்கூறு வகையை (uml.property) உருவாக்கி பின்னர் பண்புக்கூறு மதிப்புகளை ஒதுக்கவும்.

my_attr = element_factory.create(UML.Property)
my_attr.name = "my_attr"
my_attr.typeValue = "string"
my_class.ownedAttribute = my_attr

வரைபடத்தில் இதைச் சேர்ப்பது இது போல் தெரிகிறது:

my_diagram = element_factory.create(Diagram)
drop(my_class, my_diagram, x=0, y=0)
draw(my_diagram, format="svg")

நீங்கள் மாதிரியைச் சேமித்தால், உங்கள் மாற்றங்கள் தொடர்ந்து உள்ளன:

model_filename = "../my-model.gaphor"
with open(model_filename, "w") as out:
    storage.save(out, element_factory)

கூறுகளைப் புதுப்பித்தல்

ஏற்கனவே உள்ள கூறுகளை நீங்கள் புதுப்பிக்க வேண்டும் என்றால், உறுப்பு ஐடியைக் கண்காணிப்பதன் மூலம் இதைச் செய்யலாம். மாதிரியில் உள்ள ஒவ்வொரு உறுப்புக்கும் ஒரு தனித்துவமான உள் ஐடி உள்ளது. மீண்டும் எங்களுக்கு கஃபரிடமிருந்து சில இறக்குமதிகள் தேவை:

from pathlib import Path

from gaphor import UML
from gaphor import SysML
from gaphor.application import Session  # needed to run services
from gaphor.transaction import Transaction  # needed to make changes
from gaphor.storage import storage  # needed to save to file

நாங்கள் பயன்படுத்தும் சேவைகளைத் தொடங்கவும்:

session = Session(
    services=[
        "event_manager",
        "component_registry",
        "element_factory",
        "element_dispatcher",
        "modeling_language",
    ]
)

# Get services we need.
element_factory = session.get_service("element_factory")
modeling_language = session.get_service("modeling_language")
event_manager = session.get_service("event_manager")

மற்றும் அமர்வுக்கு மாதிரியில் ஏற்றவும்

with open(model_filename, encoding="utf-8") as file_obj:
    storage.load(
        file_obj,
        element_factory,
        modeling_language,
    )

# Now we query the model to get the element we want to change:
the_class = next(
    element_factory.select(
        lambda e: isinstance(e, UML.Class) and e.name == "MyClass"
    ))

முக்கியமாக, மாற்றங்கள் பரிவர்த்தனை இன் ஒரு பகுதியாக செய்யப்படுகின்றன. இங்கே நாம் அதே ஐடியுடன் உறுப்பைக் கண்டுபிடித்து, பின்னர் உள்ளடக்கத்தைப் புதுப்பிக்கவும். மாற்றப்பட்ட மாதிரியை ஒரு கோப்பில் சேமிக்கிறோம்.

# change the name and write back into the model
with Transaction(event_manager) as ctx:
    the_class.name = "Not My Class Anymore"
    the_class.ownedAttribute[0].typeValue = "updated string"

# Write changes to file here
with open(model_filename, "w") as out:
    storage.save(out, element_factory)

வேறு என்ன

தெரிந்து கொள்ள வேறு என்ன இருக்கிறது…

• பெறப்பட்ட சங்கங்களை கஃபர் ஆதரிக்கிறது. எடுத்துக்காட்டாக, `உறுப்பு. உரிமையாளர் உறுப்பை சுட்டிக்காட்டுகிறது. ஒரு பண்புக்கூறுக்கு அது கொண்டிருக்கும் வகுப்பாக இருக்கும்.

• Gaphor.uml.recipes தொகுதி கூறுகள் மற்றும் அவற்றின் சங்கங்களை கையாள பல செயல்பாடுகளைக் கொண்டுள்ளது.

• கொடுக்கப்பட்ட மாடலிங் மொழிக்கான சோதனைகள் உறுப்பு உருவாக்கம் மற்றும் மாற்றத்தின் குறிப்பு எடுத்துக்காட்டுகளைக் கண்டறிய ஒரு நல்ல இடமாகும்.

• அனைத்து தரவு மாதிரிகள் டாக்சின் மாடலிங் மொழிகள் பிரிவில் விவரிக்கப்பட்டுள்ளன.

• நீங்கள் காஃபரின் கன்சோலைப் பயன்படுத்தினால், நீங்கள் ஒரு பரிவர்த்தனையில் அனைத்து மாற்றங்களையும் பயன்படுத்த வேண்டும், அல்லது அவை பிழையை ஏற்படுத்தும்.

• ஒரு குறியீடு செனரேட்டரின் விரிவான எடுத்துக்காட்டு நீங்கள் விரும்பினால், [kaphor’s coder தொகுதி] (https://github.com/gaphor/gaphor/blob/main/gaphor/codegen/coder.py) ஐப் பாருங்கள். காஃபர் பயன்படுத்தும் தரவு மாதிரிகளுக்கான குறியீட்டை உருவாக்க இந்த தொகுதி பயன்படுத்தப்படுகிறது.

• இந்த பக்கம் myst-nb உடன் வழங்கப்படுகிறது. இது உண்மையில் சூபிட்டர் நோட்புக்!

எடுத்துக்காட்டுகள்

பின்வரும் துணுக்குகளுக்கு மேலே உள்ள தகவல்களை விரிவாக்குவது தேவைகள் மற்றும் இடைமுகங்களை எவ்வாறு உருவாக்குவது என்பதைக் காட்டுகிறது.

உரை புலங்களிலிருந்து தேவைகள்

txts = ['req1', 'req2', 'bob the cat']
outfile = "requirement_example.gaphor"
with Transaction(event_manager) as ctx:
    my_diagram = element_factory.create(Diagram)
    my_diagram.name= 'my diagram'
    reqPackage = element_factory.create(UML.Package)
    reqPackage.name = "Requirements"
    drop(reqPackage, my_diagram, x=0, y=0)


    for req_id,txt in enumerate(txts):
        my_class = element_factory.create(SysML.sysml.Requirement)
        my_class.name = f"{req_id}-{txt[:3]}"
        my_class.text = f"{txt}"
        my_class.externalId = f"{req_id}"

        drop(my_class, my_diagram, x=0, y=0)

    # Save the model or export diagrams.

அகராதிகளிலிருந்து இடைமுகங்கள்

# get interface definitions from file into this dictionary format
interfaces = {'Interface1': ['signal1:type1', 'signal2:type1', 'signal3:type1'],
              'Interface2': ['signal4:type2', 'signal5:type2', 'signal6:type2']}
outfile = 'interface_example.gaphor'
with Transaction(event_manager) as ctx:
    my_diagram = element_factory.create(UML.Diagram)
    my_diagram.name=' my diagram'
    intPackage = element_factory.create(UML.Package)
    intPackage.name = "Interfaces"
    drop(intPackage, my_diagram, x=0, y=0)


    for interface,signals in interfaces.items():
        my_class = element_factory.create(UML.uml.Interface)
        my_class.name = f"{interface}"
        for s in signals:
            my_attr = element_factory.create(UML.Property)
            name,vtype = s.split(':')
            my_attr.name = name
            my_attr.typeValue = vtype
            my_class.ownedAttribute = my_attr

        drop(my_class, my_diagram, x=0, y=0)


    # Save the model or export diagrams.

அடிப்படை சரிபார்ப்பு

சில எளிய சரிபார்ப்பு காசோலைகளை உறுப்புகளைத் தேர்ந்தெடுத்து மதிப்பீடு செய்ய இரண்டு சிறிய செயல்பாடுகளைப் பயன்படுத்தி இயக்க முடியும்.

# As before assume we have a factory service and the model is loaded
# Define a function to select an element
def element_select(element):
    return isinstance(element, UML.Class)


# Define a validation rule - names must be capatalised
def rule(element):
    return element.name[0].isupper()


# Define a message to display if the element fails the validation
msg = "Class Names must be capitalised"

element = next(element_factory.select(element_select))
is_valid = rule(element)
if not is_valid:
    print(msg)

இங்கே மற்றொரு எடுத்துக்காட்டு:

• எடுத்துக்காட்டு: காஃபர் சேவைகள்