diff --git a/tercen/model/base.py b/tercen/model/base.py index 8a1ee2d..fb44190 100644 --- a/tercen/model/base.py +++ b/tercen/model/base.py @@ -1,10 +1,9 @@ import tercen.model.vocabulary as Vocabulary -from tercen.base.BaseObject import BaseObject -import inspect -class SciObjectBase(BaseObject): +class SciObjectBase: def __init__(self, m=None): + import tercen.model.impl as impl if m is not None: self.fromJson(m) @@ -12,6 +11,7 @@ def __init__(self, m=None): super().__init__(m) def fromJson(self, m): + import tercen.model.impl as impl super().fromJson(m) self.subKind = m.get(Vocabulary.SUBKIND) if self.subKind is None and m.get(Vocabulary.KIND) != Vocabulary.SciObject_CLASS: @@ -19,419 +19,420 @@ def fromJson(self, m): @classmethod def createFromJson(cls, m): + import tercen.model.impl as impl kind = m.get(Vocabulary.KIND) if kind == Vocabulary.SciObject_CLASS: - return SciObject(m) + return impl.SciObject(m) if kind == Vocabulary.EnumeratedProperty_CLASS: - return EnumeratedProperty(m) + return impl.EnumeratedProperty(m) if kind == Vocabulary.FactorsProperty_CLASS: - return FactorsProperty(m) + return impl.FactorsProperty(m) if kind == Vocabulary.FormulaProperty_CLASS: - return FormulaProperty(m) + return impl.FormulaProperty(m) if kind == Vocabulary.DoubleProperty_CLASS: - return DoubleProperty(m) + return impl.DoubleProperty(m) if kind == Vocabulary.StringProperty_CLASS: - return StringProperty(m) + return impl.StringProperty(m) if kind == Vocabulary.BooleanProperty_CLASS: - return BooleanProperty(m) + return impl.BooleanProperty(m) if kind == Vocabulary.GateOperatorModel_CLASS: - return GateOperatorModel(m) + return impl.GateOperatorModel(m) if kind == Vocabulary.AnnotationOperatorModel_CLASS: - return AnnotationOperatorModel(m) + return impl.AnnotationOperatorModel(m) if kind == Vocabulary.NamedFilter_CLASS: - return NamedFilter(m) + return impl.NamedFilter(m) if kind == Vocabulary.FilterExpr2d_CLASS: - return FilterExpr2d(m) + return impl.FilterExpr2d(m) if kind == Vocabulary.Filter_CLASS: - return Filter(m) + return impl.Filter(m) if kind == Vocabulary.FilterExpr_CLASS: - return FilterExpr(m) + return impl.FilterExpr(m) if kind == Vocabulary.RunningState_CLASS: - return RunningState(m) + return impl.RunningState(m) if kind == Vocabulary.RunningDependentState_CLASS: - return RunningDependentState(m) + return impl.RunningDependentState(m) if kind == Vocabulary.FailedState_CLASS: - return FailedState(m) + return impl.FailedState(m) if kind == Vocabulary.CanceledState_CLASS: - return CanceledState(m) + return impl.CanceledState(m) if kind == Vocabulary.DoneState_CLASS: - return DoneState(m) + return impl.DoneState(m) if kind == Vocabulary.InitState_CLASS: - return InitState(m) + return impl.InitState(m) if kind == Vocabulary.PendingState_CLASS: - return PendingState(m) + return impl.PendingState(m) if kind == Vocabulary.StorageProfile_CLASS: - return StorageProfile(m) + return impl.StorageProfile(m) if kind == Vocabulary.RunProfile_CLASS: - return RunProfile(m) + return impl.RunProfile(m) if kind == Vocabulary.CpuTimeProfile_CLASS: - return CpuTimeProfile(m) + return impl.CpuTimeProfile(m) if kind == Vocabulary.TableProfile_CLASS: - return TableProfile(m) + return impl.TableProfile(m) if kind == Vocabulary.ApiCallProfile_CLASS: - return ApiCallProfile(m) + return impl.ApiCallProfile(m) if kind == Vocabulary.TableRelation_CLASS: - return TableRelation(m) + return impl.TableRelation(m) if kind == Vocabulary.WhereRelation_CLASS: - return WhereRelation(m) + return impl.WhereRelation(m) if kind == Vocabulary.DistinctRelation_CLASS: - return DistinctRelation(m) + return impl.DistinctRelation(m) if kind == Vocabulary.ReferenceRelation_CLASS: - return ReferenceRelation(m) + return impl.ReferenceRelation(m) if kind == Vocabulary.InMemoryRelation_CLASS: - return InMemoryRelation(m) + return impl.InMemoryRelation(m) if kind == Vocabulary.RenameRelation_CLASS: - return RenameRelation(m) + return impl.RenameRelation(m) if kind == Vocabulary.UnionRelation_CLASS: - return UnionRelation(m) + return impl.UnionRelation(m) if kind == Vocabulary.SimpleRelation_CLASS: - return SimpleRelation(m) + return impl.SimpleRelation(m) if kind == Vocabulary.GatherRelation_CLASS: - return GatherRelation(m) + return impl.GatherRelation(m) if kind == Vocabulary.CompositeRelation_CLASS: - return CompositeRelation(m) + return impl.CompositeRelation(m) if kind == Vocabulary.GroupByRelation_CLASS: - return GroupByRelation(m) + return impl.GroupByRelation(m) if kind == Vocabulary.DataStep_CLASS: - return DataStep(m) + return impl.DataStep(m) if kind == Vocabulary.MeltStep_CLASS: - return MeltStep(m) + return impl.MeltStep(m) if kind == Vocabulary.JoinStep_CLASS: - return JoinStep(m) + return impl.JoinStep(m) if kind == Vocabulary.WizardStep_CLASS: - return WizardStep(m) + return impl.WizardStep(m) if kind == Vocabulary.CrossTabStep_CLASS: - return CrossTabStep(m) + return impl.CrossTabStep(m) if kind == Vocabulary.GroupStep_CLASS: - return GroupStep(m) + return impl.GroupStep(m) if kind == Vocabulary.InStep_CLASS: - return InStep(m) + return impl.InStep(m) if kind == Vocabulary.OutStep_CLASS: - return OutStep(m) + return impl.OutStep(m) if kind == Vocabulary.TableStep_CLASS: - return TableStep(m) + return impl.TableStep(m) if kind == Vocabulary.NamespaceStep_CLASS: - return NamespaceStep(m) + return impl.NamespaceStep(m) if kind == Vocabulary.RelationStep_CLASS: - return RelationStep(m) + return impl.RelationStep(m) if kind == Vocabulary.ExportStep_CLASS: - return ExportStep(m) + return impl.ExportStep(m) if kind == Vocabulary.ModelStep_CLASS: - return ModelStep(m) + return impl.ModelStep(m) if kind == Vocabulary.ViewStep_CLASS: - return ViewStep(m) + return impl.ViewStep(m) if kind == Vocabulary.InputPort_CLASS: - return InputPort(m) + return impl.InputPort(m) if kind == Vocabulary.OutputPort_CLASS: - return OutputPort(m) + return impl.OutputPort(m) if kind == Vocabulary.GarbageTasks_CLASS: - return GarbageTasks(m) + return impl.GarbageTasks(m) if kind == Vocabulary.GarbageTasks2_CLASS: - return GarbageTasks2(m) + return impl.GarbageTasks2(m) if kind == Vocabulary.Team_CLASS: - return Team(m) + return impl.Team(m) if kind == Vocabulary.RSourceLibrary_CLASS: - return RSourceLibrary(m) + return impl.RSourceLibrary(m) if kind == Vocabulary.RenvInstalledLibrary_CLASS: - return RenvInstalledLibrary(m) + return impl.RenvInstalledLibrary(m) if kind == Vocabulary.ShinyOperator_CLASS: - return ShinyOperator(m) + return impl.ShinyOperator(m) if kind == Vocabulary.DockerWebAppOperator_CLASS: - return DockerWebAppOperator(m) + return impl.DockerWebAppOperator(m) if kind == Vocabulary.DockerOperator_CLASS: - return DockerOperator(m) + return impl.DockerOperator(m) if kind == Vocabulary.ROperator_CLASS: - return ROperator(m) + return impl.ROperator(m) if kind == Vocabulary.WebAppOperator_CLASS: - return WebAppOperator(m) + return impl.WebAppOperator(m) if kind == Vocabulary.GitOperator_CLASS: - return GitOperator(m) + return impl.GitOperator(m) if kind == Vocabulary.CubeQueryTableSchema_CLASS: - return CubeQueryTableSchema(m) + return impl.CubeQueryTableSchema(m) if kind == Vocabulary.TableSchema_CLASS: - return TableSchema(m) + return impl.TableSchema(m) if kind == Vocabulary.ComputedTableSchema_CLASS: - return ComputedTableSchema(m) + return impl.ComputedTableSchema(m) if kind == Vocabulary.Issue_CLASS: - return Issue(m) + return impl.Issue(m) if kind == Vocabulary.FileDocument_CLASS: - return FileDocument(m) + return impl.FileDocument(m) if kind == Vocabulary.FolderDocument_CLASS: - return FolderDocument(m) + return impl.FolderDocument(m) if kind == Vocabulary.Schema_CLASS: - return Schema(m) + return impl.Schema(m) if kind == Vocabulary.IssueMessage_CLASS: - return IssueMessage(m) + return impl.IssueMessage(m) if kind == Vocabulary.Workflow_CLASS: - return Workflow(m) + return impl.Workflow(m) if kind == Vocabulary.User_CLASS: - return User(m) + return impl.User(m) if kind == Vocabulary.RLibrary_CLASS: - return RLibrary(m) + return impl.RLibrary(m) if kind == Vocabulary.Operator_CLASS: - return Operator(m) + return impl.Operator(m) if kind == Vocabulary.WorkerEndpoint_CLASS: - return WorkerEndpoint(m) + return impl.WorkerEndpoint(m) if kind == Vocabulary.ProjectDocument_CLASS: - return ProjectDocument(m) + return impl.ProjectDocument(m) if kind == Vocabulary.Project_CLASS: - return Project(m) + return impl.Project(m) if kind == Vocabulary.SubscriptionPlan_CLASS: - return SubscriptionPlan(m) + return impl.SubscriptionPlan(m) if kind == Vocabulary.RunComputationTask_CLASS: - return RunComputationTask(m) + return impl.RunComputationTask(m) if kind == Vocabulary.SaveComputationResultTask_CLASS: - return SaveComputationResultTask(m) + return impl.SaveComputationResultTask(m) if kind == Vocabulary.ComputationTask_CLASS: - return ComputationTask(m) + return impl.ComputationTask(m) if kind == Vocabulary.ImportGitWorkflowTask_CLASS: - return ImportGitWorkflowTask(m) + return impl.ImportGitWorkflowTask(m) if kind == Vocabulary.ExportWorkflowTask_CLASS: - return ExportWorkflowTask(m) + return impl.ExportWorkflowTask(m) if kind == Vocabulary.CSVTask_CLASS: - return CSVTask(m) + return impl.CSVTask(m) if kind == Vocabulary.CubeQueryTask_CLASS: - return CubeQueryTask(m) + return impl.CubeQueryTask(m) if kind == Vocabulary.ImportWorkflowTask_CLASS: - return ImportWorkflowTask(m) + return impl.ImportWorkflowTask(m) if kind == Vocabulary.TestOperatorTask_CLASS: - return TestOperatorTask(m) + return impl.TestOperatorTask(m) if kind == Vocabulary.ImportGitDatasetTask_CLASS: - return ImportGitDatasetTask(m) + return impl.ImportGitDatasetTask(m) if kind == Vocabulary.RunWorkflowTask_CLASS: - return RunWorkflowTask(m) + return impl.RunWorkflowTask(m) if kind == Vocabulary.RunWebAppTask_CLASS: - return RunWebAppTask(m) + return impl.RunWebAppTask(m) if kind == Vocabulary.ExportTableTask_CLASS: - return ExportTableTask(m) + return impl.ExportTableTask(m) if kind == Vocabulary.ProjectTask_CLASS: - return ProjectTask(m) + return impl.ProjectTask(m) if kind == Vocabulary.GlTask_CLASS: - return GlTask(m) + return impl.GlTask(m) if kind == Vocabulary.LibraryTask_CLASS: - return LibraryTask(m) + return impl.LibraryTask(m) if kind == Vocabulary.CreateGitOperatorTask_CLASS: - return CreateGitOperatorTask(m) + return impl.CreateGitOperatorTask(m) if kind == Vocabulary.GitProjectTask_CLASS: - return GitProjectTask(m) + return impl.GitProjectTask(m) if kind == Vocabulary.TaskLogEvent_CLASS: - return TaskLogEvent(m) + return impl.TaskLogEvent(m) if kind == Vocabulary.TaskProgressEvent_CLASS: - return TaskProgressEvent(m) + return impl.TaskProgressEvent(m) if kind == Vocabulary.TaskDataEvent_CLASS: - return TaskDataEvent(m) + return impl.TaskDataEvent(m) if kind == Vocabulary.TaskStateEvent_CLASS: - return TaskStateEvent(m) + return impl.TaskStateEvent(m) if kind == Vocabulary.PatchRecords_CLASS: - return PatchRecords(m) + return impl.PatchRecords(m) if kind == Vocabulary.TaskEvent_CLASS: - return TaskEvent(m) + return impl.TaskEvent(m) if kind == Vocabulary.GenericEvent_CLASS: - return GenericEvent(m) + return impl.GenericEvent(m) if kind == Vocabulary.GarbageObject_CLASS: - return GarbageObject(m) + return impl.GarbageObject(m) if kind == Vocabulary.Activity_CLASS: - return Activity(m) + return impl.Activity(m) if kind == Vocabulary.Document_CLASS: - return Document(m) + return impl.Document(m) if kind == Vocabulary.Lock_CLASS: - return Lock(m) + return impl.Lock(m) if kind == Vocabulary.Task_CLASS: - return Task(m) + return impl.Task(m) if kind == Vocabulary.Event_CLASS: - return Event(m) + return impl.Event(m) if kind == Vocabulary.UserSecret_CLASS: - return UserSecret(m) + return impl.UserSecret(m) if kind == Vocabulary.Column_CLASS: - return Column(m) + return impl.Column(m) if kind == Vocabulary.StartProcess_CLASS: - return StartProcess(m) + return impl.StartProcess(m) if kind == Vocabulary.Relation_CLASS: - return Relation(m) + return impl.Relation(m) if kind == Vocabulary.Step_CLASS: - return Step(m) + return impl.Step(m) if kind == Vocabulary.Port_CLASS: - return Port(m) + return impl.Port(m) if kind == Vocabulary.PersistentObject_CLASS: - return PersistentObject(m) + return impl.PersistentObject(m) if kind == Vocabulary.Link_CLASS: - return Link(m) + return impl.Link(m) if kind == Vocabulary.ColumnSchema_CLASS: - return ColumnSchema(m) + return impl.ColumnSchema(m) if kind == Vocabulary.CSVFileMetadata_CLASS: - return CSVFileMetadata(m) + return impl.CSVFileMetadata(m) if kind == Vocabulary.JetPalette_CLASS: - return JetPalette(m) + return impl.JetPalette(m) if kind == Vocabulary.RampPalette_CLASS: - return RampPalette(m) + return impl.RampPalette(m) if kind == Vocabulary.CategoryPalette_CLASS: - return CategoryPalette(m) + return impl.CategoryPalette(m) if kind == Vocabulary.DoubleColorElement_CLASS: - return DoubleColorElement(m) + return impl.DoubleColorElement(m) if kind == Vocabulary.StringColorElement_CLASS: - return StringColorElement(m) + return impl.StringColorElement(m) if kind == Vocabulary.TableStepModel_CLASS: - return TableStepModel(m) + return impl.TableStepModel(m) if kind == Vocabulary.Crosstab_CLASS: - return Crosstab(m) + return impl.Crosstab(m) if kind == Vocabulary.JoinStepModel_CLASS: - return JoinStepModel(m) + return impl.JoinStepModel(m) if kind == Vocabulary.WizardStepModel_CLASS: - return WizardStepModel(m) + return impl.WizardStepModel(m) if kind == Vocabulary.MeltStepModel_CLASS: - return MeltStepModel(m) + return impl.MeltStepModel(m) if kind == Vocabulary.ExportModel_CLASS: - return ExportModel(m) + return impl.ExportModel(m) if kind == Vocabulary.Attribute_CLASS: - return Attribute(m) + return impl.Attribute(m) if kind == Vocabulary.MappingFactor_CLASS: - return MappingFactor(m) + return impl.MappingFactor(m) if kind == Vocabulary.ChartLine_CLASS: - return ChartLine(m) + return impl.ChartLine(m) if kind == Vocabulary.ChartPoint_CLASS: - return ChartPoint(m) + return impl.ChartPoint(m) if kind == Vocabulary.ChartHeatmap_CLASS: - return ChartHeatmap(m) + return impl.ChartHeatmap(m) if kind == Vocabulary.ChartBar_CLASS: - return ChartBar(m) + return impl.ChartBar(m) if kind == Vocabulary.ChartSize_CLASS: - return ChartSize(m) + return impl.ChartSize(m) if kind == Vocabulary.Rectangle_CLASS: - return Rectangle(m) + return impl.Rectangle(m) if kind == Vocabulary.ResourceSummary_CLASS: - return ResourceSummary(m) + return impl.ResourceSummary(m) if kind == Vocabulary.BillingInfo_CLASS: - return BillingInfo(m) + return impl.BillingInfo(m) if kind == Vocabulary.Property_CLASS: - return Property(m) + return impl.Property(m) if kind == Vocabulary.Version_CLASS: - return Version(m) + return impl.Version(m) if kind == Vocabulary.Filters_CLASS: - return Filters(m) + return impl.Filters(m) if kind == Vocabulary.CubeQuery_CLASS: - return CubeQuery(m) + return impl.CubeQuery(m) if kind == Vocabulary.UserSession_CLASS: - return UserSession(m) + return impl.UserSession(m) if kind == Vocabulary.Table_CLASS: - return Table(m) + return impl.Table(m) if kind == Vocabulary.Acl_CLASS: - return Acl(m) + return impl.Acl(m) if kind == Vocabulary.GateNode_CLASS: - return GateNode(m) + return impl.GateNode(m) if kind == Vocabulary.TaskSummary_CLASS: - return TaskSummary(m) + return impl.TaskSummary(m) if kind == Vocabulary.Token_CLASS: - return Token(m) + return impl.Token(m) if kind == Vocabulary.JoinOperator_CLASS: - return JoinOperator(m) + return impl.JoinOperator(m) if kind == Vocabulary.OperatorModel_CLASS: - return OperatorModel(m) + return impl.OperatorModel(m) if kind == Vocabulary.CrosstabTable_CLASS: - return CrosstabTable(m) + return impl.CrosstabTable(m) if kind == Vocabulary.XYAxisList_CLASS: - return XYAxisList(m) + return impl.XYAxisList(m) if kind == Vocabulary.FilterTopExpr_CLASS: - return FilterTopExpr(m) + return impl.FilterTopExpr(m) if kind == Vocabulary.PatchRecord_CLASS: - return PatchRecord(m) + return impl.PatchRecord(m) if kind == Vocabulary.State_CLASS: - return State(m) + return impl.State(m) if kind == Vocabulary.ColumnSchemaMetaData_CLASS: - return ColumnSchemaMetaData(m) + return impl.ColumnSchemaMetaData(m) if kind == Vocabulary.Privilege_CLASS: - return Privilege(m) + return impl.Privilege(m) if kind == Vocabulary.ViesInfo_CLASS: - return ViesInfo(m) + return impl.ViesInfo(m) if kind == Vocabulary.RDescription_CLASS: - return RDescription(m) + return impl.RDescription(m) if kind == Vocabulary.Profile_CLASS: - return Profile(m) + return impl.Profile(m) if kind == Vocabulary.Date_CLASS: - return Date(m) + return impl.Date(m) if kind == Vocabulary.StepState_CLASS: - return StepState(m) + return impl.StepState(m) if kind == Vocabulary.OperatorResult_CLASS: - return OperatorResult(m) + return impl.OperatorResult(m) if kind == Vocabulary.Address_CLASS: - return Address(m) + return impl.Address(m) if kind == Vocabulary.XYAxis_CLASS: - return XYAxis(m) + return impl.XYAxis(m) if kind == Vocabulary.IdObject_CLASS: - return IdObject(m) + return impl.IdObject(m) if kind == Vocabulary.Principal_CLASS: - return Principal(m) + return impl.Principal(m) if kind == Vocabulary.Url_CLASS: - return Url(m) + return impl.Url(m) if kind == Vocabulary.RProxy_CLASS: - return RProxy(m) + return impl.RProxy(m) if kind == Vocabulary.Pair_CLASS: - return Pair(m) + return impl.Pair(m) if kind == Vocabulary.FileMetadata_CLASS: - return FileMetadata(m) + return impl.FileMetadata(m) if kind == Vocabulary.Worker_CLASS: - return Worker(m) + return impl.Worker(m) if kind == Vocabulary.Ace_CLASS: - return Ace(m) + return impl.Ace(m) if kind == Vocabulary.Labels_CLASS: - return Labels(m) + return impl.Labels(m) if kind == Vocabulary.OperatorSettings_CLASS: - return OperatorSettings(m) + return impl.OperatorSettings(m) if kind == Vocabulary.TableSummary_CLASS: - return TableSummary(m) + return impl.TableSummary(m) if kind == Vocabulary.Point_CLASS: - return Point(m) + return impl.Point(m) if kind == Vocabulary.Summary_CLASS: - return Summary(m) + return impl.Summary(m) if kind == Vocabulary.Errors_CLASS: - return Errors(m) + return impl.Errors(m) if kind == Vocabulary.Palette_CLASS: - return Palette(m) + return impl.Palette(m) if kind == Vocabulary.GraphicalFactor_CLASS: - return GraphicalFactor(m) + return impl.GraphicalFactor(m) if kind == Vocabulary.ColorList_CLASS: - return ColorList(m) + return impl.ColorList(m) if kind == Vocabulary.SearchResult_CLASS: - return SearchResult(m) + return impl.SearchResult(m) if kind == Vocabulary.AnnotationModel_CLASS: - return AnnotationModel(m) + return impl.AnnotationModel(m) if kind == Vocabulary.ColorElement_CLASS: - return ColorElement(m) + return impl.ColorElement(m) if kind == Vocabulary.PreProcessor_CLASS: - return PreProcessor(m) + return impl.PreProcessor(m) if kind == Vocabulary.Properties_CLASS: - return Properties(m) + return impl.Properties(m) if kind == Vocabulary.PropertyValue_CLASS: - return PropertyValue(m) + return impl.PropertyValue(m) if kind == Vocabulary.AclContext_CLASS: - return AclContext(m) + return impl.AclContext(m) if kind == Vocabulary.OperatorUnitTest_CLASS: - return OperatorUnitTest(m) + return impl.OperatorUnitTest(m) if kind == Vocabulary.StepModel_CLASS: - return StepModel(m) + return impl.StepModel(m) if kind == Vocabulary.Profiles_CLASS: - return Profiles(m) + return impl.Profiles(m) if kind == Vocabulary.OperatorRef_CLASS: - return OperatorRef(m) + return impl.OperatorRef(m) if kind == Vocabulary.Factor_CLASS: - return Factor(m) + return impl.Factor(m) if kind == Vocabulary.ColumnPair_CLASS: - return ColumnPair(m) + return impl.ColumnPair(m) if kind == Vocabulary.TaxId_CLASS: - return TaxId(m) + return impl.TaxId(m) if kind == Vocabulary.Plan_CLASS: - return Plan(m) + return impl.Plan(m) if kind == Vocabulary.CSVParserParam_CLASS: - return CSVParserParam(m) + return impl.CSVParserParam(m) if kind == Vocabulary.AppDesign_CLASS: - return AppDesign(m) + return impl.AppDesign(m) if kind == Vocabulary.Axis_CLASS: - return Axis(m) + return impl.Axis(m) if kind == Vocabulary.Colors_CLASS: - return Colors(m) + return impl.Colors(m) if kind == Vocabulary.TableProperties_CLASS: - return TableProperties(m) + return impl.TableProperties(m) if kind == Vocabulary.Chart_CLASS: - return Chart(m) + return impl.Chart(m) raise ValueError("bad kind : " + kind + " for class SciObject in createFromJson") @@ -445,16 +446,10 @@ def toJson(self): return m -class SciObject(SciObjectBase): - def __init__(self, m=None): - super().__init__(m) - - -class IdObjectBase(SciObject): +class IdObjectBase: def __init__(self, m=None): import tercen.model.impl as impl - if ("SciObject", impl.SciObject) in inspect.getmembers(impl): - IdObjectBase.__bases__ = (impl.SciObject,) + IdObjectBase.__bases__ = (impl.SciObject,) if m is None: super().__init__(m) self.id = "" @@ -462,6 +457,7 @@ def __init__(self, m=None): self.fromJson(m) def fromJson(self, m): + import tercen.model.impl as impl super().fromJson(m) self.subKind = m.get(Vocabulary.SUBKIND) if self.subKind is None and m.get(Vocabulary.KIND) != Vocabulary.IdObject_CLASS: @@ -470,197 +466,198 @@ def fromJson(self, m): @classmethod def createFromJson(cls, m): + import tercen.model.impl as impl kind = m.get(Vocabulary.KIND) if kind == Vocabulary.IdObject_CLASS: - return IdObject(m) + return impl.IdObject(m) if kind == Vocabulary.TableRelation_CLASS: - return TableRelation(m) + return impl.TableRelation(m) if kind == Vocabulary.WhereRelation_CLASS: - return WhereRelation(m) + return impl.WhereRelation(m) if kind == Vocabulary.DistinctRelation_CLASS: - return DistinctRelation(m) + return impl.DistinctRelation(m) if kind == Vocabulary.ReferenceRelation_CLASS: - return ReferenceRelation(m) + return impl.ReferenceRelation(m) if kind == Vocabulary.InMemoryRelation_CLASS: - return InMemoryRelation(m) + return impl.InMemoryRelation(m) if kind == Vocabulary.RenameRelation_CLASS: - return RenameRelation(m) + return impl.RenameRelation(m) if kind == Vocabulary.UnionRelation_CLASS: - return UnionRelation(m) + return impl.UnionRelation(m) if kind == Vocabulary.SimpleRelation_CLASS: - return SimpleRelation(m) + return impl.SimpleRelation(m) if kind == Vocabulary.GatherRelation_CLASS: - return GatherRelation(m) + return impl.GatherRelation(m) if kind == Vocabulary.CompositeRelation_CLASS: - return CompositeRelation(m) + return impl.CompositeRelation(m) if kind == Vocabulary.GroupByRelation_CLASS: - return GroupByRelation(m) + return impl.GroupByRelation(m) if kind == Vocabulary.DataStep_CLASS: - return DataStep(m) + return impl.DataStep(m) if kind == Vocabulary.MeltStep_CLASS: - return MeltStep(m) + return impl.MeltStep(m) if kind == Vocabulary.JoinStep_CLASS: - return JoinStep(m) + return impl.JoinStep(m) if kind == Vocabulary.WizardStep_CLASS: - return WizardStep(m) + return impl.WizardStep(m) if kind == Vocabulary.CrossTabStep_CLASS: - return CrossTabStep(m) + return impl.CrossTabStep(m) if kind == Vocabulary.GroupStep_CLASS: - return GroupStep(m) + return impl.GroupStep(m) if kind == Vocabulary.InStep_CLASS: - return InStep(m) + return impl.InStep(m) if kind == Vocabulary.OutStep_CLASS: - return OutStep(m) + return impl.OutStep(m) if kind == Vocabulary.TableStep_CLASS: - return TableStep(m) + return impl.TableStep(m) if kind == Vocabulary.NamespaceStep_CLASS: - return NamespaceStep(m) + return impl.NamespaceStep(m) if kind == Vocabulary.RelationStep_CLASS: - return RelationStep(m) + return impl.RelationStep(m) if kind == Vocabulary.ExportStep_CLASS: - return ExportStep(m) + return impl.ExportStep(m) if kind == Vocabulary.ModelStep_CLASS: - return ModelStep(m) + return impl.ModelStep(m) if kind == Vocabulary.ViewStep_CLASS: - return ViewStep(m) + return impl.ViewStep(m) if kind == Vocabulary.InputPort_CLASS: - return InputPort(m) + return impl.InputPort(m) if kind == Vocabulary.OutputPort_CLASS: - return OutputPort(m) + return impl.OutputPort(m) if kind == Vocabulary.GarbageTasks_CLASS: - return GarbageTasks(m) + return impl.GarbageTasks(m) if kind == Vocabulary.GarbageTasks2_CLASS: - return GarbageTasks2(m) + return impl.GarbageTasks2(m) if kind == Vocabulary.Team_CLASS: - return Team(m) + return impl.Team(m) if kind == Vocabulary.RSourceLibrary_CLASS: - return RSourceLibrary(m) + return impl.RSourceLibrary(m) if kind == Vocabulary.RenvInstalledLibrary_CLASS: - return RenvInstalledLibrary(m) + return impl.RenvInstalledLibrary(m) if kind == Vocabulary.ShinyOperator_CLASS: - return ShinyOperator(m) + return impl.ShinyOperator(m) if kind == Vocabulary.DockerWebAppOperator_CLASS: - return DockerWebAppOperator(m) + return impl.DockerWebAppOperator(m) if kind == Vocabulary.DockerOperator_CLASS: - return DockerOperator(m) + return impl.DockerOperator(m) if kind == Vocabulary.ROperator_CLASS: - return ROperator(m) + return impl.ROperator(m) if kind == Vocabulary.WebAppOperator_CLASS: - return WebAppOperator(m) + return impl.WebAppOperator(m) if kind == Vocabulary.GitOperator_CLASS: - return GitOperator(m) + return impl.GitOperator(m) if kind == Vocabulary.CubeQueryTableSchema_CLASS: - return CubeQueryTableSchema(m) + return impl.CubeQueryTableSchema(m) if kind == Vocabulary.TableSchema_CLASS: - return TableSchema(m) + return impl.TableSchema(m) if kind == Vocabulary.ComputedTableSchema_CLASS: - return ComputedTableSchema(m) + return impl.ComputedTableSchema(m) if kind == Vocabulary.Issue_CLASS: - return Issue(m) + return impl.Issue(m) if kind == Vocabulary.FileDocument_CLASS: - return FileDocument(m) + return impl.FileDocument(m) if kind == Vocabulary.FolderDocument_CLASS: - return FolderDocument(m) + return impl.FolderDocument(m) if kind == Vocabulary.Schema_CLASS: - return Schema(m) + return impl.Schema(m) if kind == Vocabulary.IssueMessage_CLASS: - return IssueMessage(m) + return impl.IssueMessage(m) if kind == Vocabulary.Workflow_CLASS: - return Workflow(m) + return impl.Workflow(m) if kind == Vocabulary.User_CLASS: - return User(m) + return impl.User(m) if kind == Vocabulary.RLibrary_CLASS: - return RLibrary(m) + return impl.RLibrary(m) if kind == Vocabulary.Operator_CLASS: - return Operator(m) + return impl.Operator(m) if kind == Vocabulary.WorkerEndpoint_CLASS: - return WorkerEndpoint(m) + return impl.WorkerEndpoint(m) if kind == Vocabulary.ProjectDocument_CLASS: - return ProjectDocument(m) + return impl.ProjectDocument(m) if kind == Vocabulary.Project_CLASS: - return Project(m) + return impl.Project(m) if kind == Vocabulary.SubscriptionPlan_CLASS: - return SubscriptionPlan(m) + return impl.SubscriptionPlan(m) if kind == Vocabulary.RunComputationTask_CLASS: - return RunComputationTask(m) + return impl.RunComputationTask(m) if kind == Vocabulary.SaveComputationResultTask_CLASS: - return SaveComputationResultTask(m) + return impl.SaveComputationResultTask(m) if kind == Vocabulary.ComputationTask_CLASS: - return ComputationTask(m) + return impl.ComputationTask(m) if kind == Vocabulary.ImportGitWorkflowTask_CLASS: - return ImportGitWorkflowTask(m) + return impl.ImportGitWorkflowTask(m) if kind == Vocabulary.ExportWorkflowTask_CLASS: - return ExportWorkflowTask(m) + return impl.ExportWorkflowTask(m) if kind == Vocabulary.CSVTask_CLASS: - return CSVTask(m) + return impl.CSVTask(m) if kind == Vocabulary.CubeQueryTask_CLASS: - return CubeQueryTask(m) + return impl.CubeQueryTask(m) if kind == Vocabulary.ImportWorkflowTask_CLASS: - return ImportWorkflowTask(m) + return impl.ImportWorkflowTask(m) if kind == Vocabulary.TestOperatorTask_CLASS: - return TestOperatorTask(m) + return impl.TestOperatorTask(m) if kind == Vocabulary.ImportGitDatasetTask_CLASS: - return ImportGitDatasetTask(m) + return impl.ImportGitDatasetTask(m) if kind == Vocabulary.RunWorkflowTask_CLASS: - return RunWorkflowTask(m) + return impl.RunWorkflowTask(m) if kind == Vocabulary.RunWebAppTask_CLASS: - return RunWebAppTask(m) + return impl.RunWebAppTask(m) if kind == Vocabulary.ExportTableTask_CLASS: - return ExportTableTask(m) + return impl.ExportTableTask(m) if kind == Vocabulary.ProjectTask_CLASS: - return ProjectTask(m) + return impl.ProjectTask(m) if kind == Vocabulary.GlTask_CLASS: - return GlTask(m) + return impl.GlTask(m) if kind == Vocabulary.LibraryTask_CLASS: - return LibraryTask(m) + return impl.LibraryTask(m) if kind == Vocabulary.CreateGitOperatorTask_CLASS: - return CreateGitOperatorTask(m) + return impl.CreateGitOperatorTask(m) if kind == Vocabulary.GitProjectTask_CLASS: - return GitProjectTask(m) + return impl.GitProjectTask(m) if kind == Vocabulary.TaskLogEvent_CLASS: - return TaskLogEvent(m) + return impl.TaskLogEvent(m) if kind == Vocabulary.TaskProgressEvent_CLASS: - return TaskProgressEvent(m) + return impl.TaskProgressEvent(m) if kind == Vocabulary.TaskDataEvent_CLASS: - return TaskDataEvent(m) + return impl.TaskDataEvent(m) if kind == Vocabulary.TaskStateEvent_CLASS: - return TaskStateEvent(m) + return impl.TaskStateEvent(m) if kind == Vocabulary.PatchRecords_CLASS: - return PatchRecords(m) + return impl.PatchRecords(m) if kind == Vocabulary.TaskEvent_CLASS: - return TaskEvent(m) + return impl.TaskEvent(m) if kind == Vocabulary.GenericEvent_CLASS: - return GenericEvent(m) + return impl.GenericEvent(m) if kind == Vocabulary.GarbageObject_CLASS: - return GarbageObject(m) + return impl.GarbageObject(m) if kind == Vocabulary.Activity_CLASS: - return Activity(m) + return impl.Activity(m) if kind == Vocabulary.Document_CLASS: - return Document(m) + return impl.Document(m) if kind == Vocabulary.Lock_CLASS: - return Lock(m) + return impl.Lock(m) if kind == Vocabulary.Task_CLASS: - return Task(m) + return impl.Task(m) if kind == Vocabulary.Event_CLASS: - return Event(m) + return impl.Event(m) if kind == Vocabulary.UserSecret_CLASS: - return UserSecret(m) + return impl.UserSecret(m) if kind == Vocabulary.Column_CLASS: - return Column(m) + return impl.Column(m) if kind == Vocabulary.StartProcess_CLASS: - return StartProcess(m) + return impl.StartProcess(m) if kind == Vocabulary.Relation_CLASS: - return Relation(m) + return impl.Relation(m) if kind == Vocabulary.Step_CLASS: - return Step(m) + return impl.Step(m) if kind == Vocabulary.Port_CLASS: - return Port(m) + return impl.Port(m) if kind == Vocabulary.PersistentObject_CLASS: - return PersistentObject(m) + return impl.PersistentObject(m) if kind == Vocabulary.Link_CLASS: - return Link(m) + return impl.Link(m) if kind == Vocabulary.ColumnSchema_CLASS: - return ColumnSchema(m) + return impl.ColumnSchema(m) raise ValueError("bad kind : " + kind + " for class IdObject in createFromJson") @@ -675,16 +672,10 @@ def toJson(self): return m -class IdObject(IdObjectBase): - def __init__(self, m=None): - super().__init__(m) - - -class PersistentObjectBase(IdObject): +class PersistentObjectBase: def __init__(self, m=None): import tercen.model.impl as impl - if ("IdObject", impl.IdObject) in inspect.getmembers(impl): - PersistentObjectBase.__bases__ = (impl.IdObject,) + PersistentObjectBase.__bases__ = (impl.IdObject,) if m is None: super().__init__(m) self.isDeleted = True @@ -693,6 +684,7 @@ def __init__(self, m=None): self.fromJson(m) def fromJson(self, m): + import tercen.model.impl as impl super().fromJson(m) self.subKind = m.get(Vocabulary.SUBKIND) if self.subKind is None and m.get(Vocabulary.KIND) != Vocabulary.PersistentObject_CLASS: @@ -702,127 +694,128 @@ def fromJson(self, m): @classmethod def createFromJson(cls, m): + import tercen.model.impl as impl kind = m.get(Vocabulary.KIND) if kind == Vocabulary.PersistentObject_CLASS: - return PersistentObject(m) + return impl.PersistentObject(m) if kind == Vocabulary.GarbageTasks_CLASS: - return GarbageTasks(m) + return impl.GarbageTasks(m) if kind == Vocabulary.GarbageTasks2_CLASS: - return GarbageTasks2(m) + return impl.GarbageTasks2(m) if kind == Vocabulary.Team_CLASS: - return Team(m) + return impl.Team(m) if kind == Vocabulary.RSourceLibrary_CLASS: - return RSourceLibrary(m) + return impl.RSourceLibrary(m) if kind == Vocabulary.RenvInstalledLibrary_CLASS: - return RenvInstalledLibrary(m) + return impl.RenvInstalledLibrary(m) if kind == Vocabulary.ShinyOperator_CLASS: - return ShinyOperator(m) + return impl.ShinyOperator(m) if kind == Vocabulary.DockerWebAppOperator_CLASS: - return DockerWebAppOperator(m) + return impl.DockerWebAppOperator(m) if kind == Vocabulary.DockerOperator_CLASS: - return DockerOperator(m) + return impl.DockerOperator(m) if kind == Vocabulary.ROperator_CLASS: - return ROperator(m) + return impl.ROperator(m) if kind == Vocabulary.WebAppOperator_CLASS: - return WebAppOperator(m) + return impl.WebAppOperator(m) if kind == Vocabulary.GitOperator_CLASS: - return GitOperator(m) + return impl.GitOperator(m) if kind == Vocabulary.CubeQueryTableSchema_CLASS: - return CubeQueryTableSchema(m) + return impl.CubeQueryTableSchema(m) if kind == Vocabulary.TableSchema_CLASS: - return TableSchema(m) + return impl.TableSchema(m) if kind == Vocabulary.ComputedTableSchema_CLASS: - return ComputedTableSchema(m) + return impl.ComputedTableSchema(m) if kind == Vocabulary.Issue_CLASS: - return Issue(m) + return impl.Issue(m) if kind == Vocabulary.FileDocument_CLASS: - return FileDocument(m) + return impl.FileDocument(m) if kind == Vocabulary.FolderDocument_CLASS: - return FolderDocument(m) + return impl.FolderDocument(m) if kind == Vocabulary.Schema_CLASS: - return Schema(m) + return impl.Schema(m) if kind == Vocabulary.IssueMessage_CLASS: - return IssueMessage(m) + return impl.IssueMessage(m) if kind == Vocabulary.Workflow_CLASS: - return Workflow(m) + return impl.Workflow(m) if kind == Vocabulary.User_CLASS: - return User(m) + return impl.User(m) if kind == Vocabulary.RLibrary_CLASS: - return RLibrary(m) + return impl.RLibrary(m) if kind == Vocabulary.Operator_CLASS: - return Operator(m) + return impl.Operator(m) if kind == Vocabulary.WorkerEndpoint_CLASS: - return WorkerEndpoint(m) + return impl.WorkerEndpoint(m) if kind == Vocabulary.ProjectDocument_CLASS: - return ProjectDocument(m) + return impl.ProjectDocument(m) if kind == Vocabulary.Project_CLASS: - return Project(m) + return impl.Project(m) if kind == Vocabulary.SubscriptionPlan_CLASS: - return SubscriptionPlan(m) + return impl.SubscriptionPlan(m) if kind == Vocabulary.RunComputationTask_CLASS: - return RunComputationTask(m) + return impl.RunComputationTask(m) if kind == Vocabulary.SaveComputationResultTask_CLASS: - return SaveComputationResultTask(m) + return impl.SaveComputationResultTask(m) if kind == Vocabulary.ComputationTask_CLASS: - return ComputationTask(m) + return impl.ComputationTask(m) if kind == Vocabulary.ImportGitWorkflowTask_CLASS: - return ImportGitWorkflowTask(m) + return impl.ImportGitWorkflowTask(m) if kind == Vocabulary.ExportWorkflowTask_CLASS: - return ExportWorkflowTask(m) + return impl.ExportWorkflowTask(m) if kind == Vocabulary.CSVTask_CLASS: - return CSVTask(m) + return impl.CSVTask(m) if kind == Vocabulary.CubeQueryTask_CLASS: - return CubeQueryTask(m) + return impl.CubeQueryTask(m) if kind == Vocabulary.ImportWorkflowTask_CLASS: - return ImportWorkflowTask(m) + return impl.ImportWorkflowTask(m) if kind == Vocabulary.TestOperatorTask_CLASS: - return TestOperatorTask(m) + return impl.TestOperatorTask(m) if kind == Vocabulary.ImportGitDatasetTask_CLASS: - return ImportGitDatasetTask(m) + return impl.ImportGitDatasetTask(m) if kind == Vocabulary.RunWorkflowTask_CLASS: - return RunWorkflowTask(m) + return impl.RunWorkflowTask(m) if kind == Vocabulary.RunWebAppTask_CLASS: - return RunWebAppTask(m) + return impl.RunWebAppTask(m) if kind == Vocabulary.ExportTableTask_CLASS: - return ExportTableTask(m) + return impl.ExportTableTask(m) if kind == Vocabulary.ProjectTask_CLASS: - return ProjectTask(m) + return impl.ProjectTask(m) if kind == Vocabulary.GlTask_CLASS: - return GlTask(m) + return impl.GlTask(m) if kind == Vocabulary.LibraryTask_CLASS: - return LibraryTask(m) + return impl.LibraryTask(m) if kind == Vocabulary.CreateGitOperatorTask_CLASS: - return CreateGitOperatorTask(m) + return impl.CreateGitOperatorTask(m) if kind == Vocabulary.GitProjectTask_CLASS: - return GitProjectTask(m) + return impl.GitProjectTask(m) if kind == Vocabulary.TaskLogEvent_CLASS: - return TaskLogEvent(m) + return impl.TaskLogEvent(m) if kind == Vocabulary.TaskProgressEvent_CLASS: - return TaskProgressEvent(m) + return impl.TaskProgressEvent(m) if kind == Vocabulary.TaskDataEvent_CLASS: - return TaskDataEvent(m) + return impl.TaskDataEvent(m) if kind == Vocabulary.TaskStateEvent_CLASS: - return TaskStateEvent(m) + return impl.TaskStateEvent(m) if kind == Vocabulary.PatchRecords_CLASS: - return PatchRecords(m) + return impl.PatchRecords(m) if kind == Vocabulary.TaskEvent_CLASS: - return TaskEvent(m) + return impl.TaskEvent(m) if kind == Vocabulary.GenericEvent_CLASS: - return GenericEvent(m) + return impl.GenericEvent(m) if kind == Vocabulary.GarbageObject_CLASS: - return GarbageObject(m) + return impl.GarbageObject(m) if kind == Vocabulary.Activity_CLASS: - return Activity(m) + return impl.Activity(m) if kind == Vocabulary.Document_CLASS: - return Document(m) + return impl.Document(m) if kind == Vocabulary.Lock_CLASS: - return Lock(m) + return impl.Lock(m) if kind == Vocabulary.Task_CLASS: - return Task(m) + return impl.Task(m) if kind == Vocabulary.Event_CLASS: - return Event(m) + return impl.Event(m) if kind == Vocabulary.UserSecret_CLASS: - return UserSecret(m) + return impl.UserSecret(m) raise ValueError("bad kind : " + kind + " for class PersistentObject in createFromJson") @@ -838,20 +831,10 @@ def toJson(self): return m -class PersistentObject(PersistentObjectBase): - def __init__(self, m=None): - if m is None: - super().__init__(m) - self.isDeleted = False - else: - self.fromJson(m) - - -class DocumentBase(PersistentObject): +class DocumentBase: def __init__(self, m=None): import tercen.model.impl as impl - if ("PersistentObject", impl.PersistentObject) in inspect.getmembers(impl): - DocumentBase.__bases__ = (impl.PersistentObject,) + DocumentBase.__bases__ = (impl.PersistentObject,) if m is None: super().__init__(m) self.description = "" @@ -861,16 +844,17 @@ def __init__(self, m=None): self.version = "" self.authors = list() self.isPublic = True - self.acl = Acl() - self.createdDate = Date() - self.lastModifiedDate = Date() + self.acl = impl.Acl() + self.createdDate = impl.Date() + self.lastModifiedDate = impl.Date() self.urls = list() self.meta = list() - self.url = Url() + self.url = impl.Url() else: self.fromJson(m) def fromJson(self, m): + import tercen.model.impl as impl super().fromJson(m) self.subKind = m.get(Vocabulary.SUBKIND) if self.subKind is None and m.get(Vocabulary.KIND) != Vocabulary.Document_CLASS: @@ -889,16 +873,16 @@ def fromJson(self, m): self.authors = m[Vocabulary.authors_DP] self.isPublic = m[Vocabulary.isPublic_DP] if m.get(Vocabulary.acl_OP) is None: - self.acl = Acl() + self.acl = impl.Acl() else: self.acl = AclBase.createFromJson(m.get(Vocabulary.acl_OP)) if m.get(Vocabulary.createdDate_OP) is None: - self.createdDate = Date() + self.createdDate = impl.Date() else: self.createdDate = DateBase.createFromJson( m.get(Vocabulary.createdDate_OP)) if m.get(Vocabulary.lastModifiedDate_OP) is None: - self.lastModifiedDate = Date() + self.lastModifiedDate = impl.Date() else: self.lastModifiedDate = DateBase.createFromJson( m.get(Vocabulary.lastModifiedDate_OP)) @@ -915,65 +899,66 @@ def fromJson(self, m): for o in m.get(Vocabulary.meta_OP): self.meta.append(PairBase.createFromJson(o)) if m.get(Vocabulary.url_OP) is None: - self.url = Url() + self.url = impl.Url() else: self.url = UrlBase.createFromJson(m.get(Vocabulary.url_OP)) @classmethod def createFromJson(cls, m): + import tercen.model.impl as impl kind = m.get(Vocabulary.KIND) if kind == Vocabulary.Document_CLASS: - return Document(m) + return impl.Document(m) if kind == Vocabulary.Team_CLASS: - return Team(m) + return impl.Team(m) if kind == Vocabulary.RSourceLibrary_CLASS: - return RSourceLibrary(m) + return impl.RSourceLibrary(m) if kind == Vocabulary.RenvInstalledLibrary_CLASS: - return RenvInstalledLibrary(m) + return impl.RenvInstalledLibrary(m) if kind == Vocabulary.ShinyOperator_CLASS: - return ShinyOperator(m) + return impl.ShinyOperator(m) if kind == Vocabulary.DockerWebAppOperator_CLASS: - return DockerWebAppOperator(m) + return impl.DockerWebAppOperator(m) if kind == Vocabulary.DockerOperator_CLASS: - return DockerOperator(m) + return impl.DockerOperator(m) if kind == Vocabulary.ROperator_CLASS: - return ROperator(m) + return impl.ROperator(m) if kind == Vocabulary.WebAppOperator_CLASS: - return WebAppOperator(m) + return impl.WebAppOperator(m) if kind == Vocabulary.GitOperator_CLASS: - return GitOperator(m) + return impl.GitOperator(m) if kind == Vocabulary.CubeQueryTableSchema_CLASS: - return CubeQueryTableSchema(m) + return impl.CubeQueryTableSchema(m) if kind == Vocabulary.TableSchema_CLASS: - return TableSchema(m) + return impl.TableSchema(m) if kind == Vocabulary.ComputedTableSchema_CLASS: - return ComputedTableSchema(m) + return impl.ComputedTableSchema(m) if kind == Vocabulary.Issue_CLASS: - return Issue(m) + return impl.Issue(m) if kind == Vocabulary.FileDocument_CLASS: - return FileDocument(m) + return impl.FileDocument(m) if kind == Vocabulary.FolderDocument_CLASS: - return FolderDocument(m) + return impl.FolderDocument(m) if kind == Vocabulary.Schema_CLASS: - return Schema(m) + return impl.Schema(m) if kind == Vocabulary.IssueMessage_CLASS: - return IssueMessage(m) + return impl.IssueMessage(m) if kind == Vocabulary.Workflow_CLASS: - return Workflow(m) + return impl.Workflow(m) if kind == Vocabulary.User_CLASS: - return User(m) + return impl.User(m) if kind == Vocabulary.RLibrary_CLASS: - return RLibrary(m) + return impl.RLibrary(m) if kind == Vocabulary.Operator_CLASS: - return Operator(m) + return impl.Operator(m) if kind == Vocabulary.WorkerEndpoint_CLASS: - return WorkerEndpoint(m) + return impl.WorkerEndpoint(m) if kind == Vocabulary.ProjectDocument_CLASS: - return ProjectDocument(m) + return impl.ProjectDocument(m) if kind == Vocabulary.Project_CLASS: - return Project(m) + return impl.Project(m) if kind == Vocabulary.SubscriptionPlan_CLASS: - return SubscriptionPlan(m) + return impl.SubscriptionPlan(m) raise ValueError("bad kind : " + kind + " for class Document in createFromJson") @@ -1000,20 +985,10 @@ def toJson(self): return m -class Document(DocumentBase): - def __init__(self, m=None): - if m is None: - super().__init__(m) - self.isPublic = False - else: - self.fromJson(m) - - -class UserBase(Document): +class UserBase: def __init__(self, m=None): import tercen.model.impl as impl - if ("Document", impl.Document) in inspect.getmembers(impl): - UserBase.__bases__ = (impl.Document,) + UserBase.__bases__ = (impl.Document,) if m is None: super().__init__(m) self.email = "" @@ -1023,12 +998,13 @@ def __init__(self, m=None): self.invitedByUsername = "" self.invitationCounts = 0 self.maxInvitation = 0 - self.teamAcl = Acl() - self.billingInfo = BillingInfo() + self.teamAcl = impl.Acl() + self.billingInfo = impl.BillingInfo() else: self.fromJson(m) def fromJson(self, m): + import tercen.model.impl as impl super().fromJson(m) self.subKind = m.get(Vocabulary.SUBKIND) if self.subKind is None and m.get(Vocabulary.KIND) != Vocabulary.User_CLASS: @@ -1044,22 +1020,23 @@ def fromJson(self, m): self.invitationCounts = m[Vocabulary.invitationCounts_DP] self.maxInvitation = m[Vocabulary.maxInvitation_DP] if m.get(Vocabulary.teamAcl_OP) is None: - self.teamAcl = Acl() + self.teamAcl = impl.Acl() else: self.teamAcl = AclBase.createFromJson(m.get(Vocabulary.teamAcl_OP)) if m.get(Vocabulary.billingInfo_OP) is None: - self.billingInfo = BillingInfo() + self.billingInfo = impl.BillingInfo() else: self.billingInfo = BillingInfoBase.createFromJson( m.get(Vocabulary.billingInfo_OP)) @classmethod def createFromJson(cls, m): + import tercen.model.impl as impl kind = m.get(Vocabulary.KIND) if kind == Vocabulary.User_CLASS: - return User(m) + return impl.User(m) if kind == Vocabulary.Team_CLASS: - return Team(m) + return impl.Team(m) raise ValueError("bad kind : " + kind + " for class User in createFromJson") @@ -1082,16 +1059,10 @@ def toJson(self): return m -class User(UserBase): - def __init__(self, m=None): - super().__init__(m) - - -class TeamBase(User): +class TeamBase: def __init__(self, m=None): import tercen.model.impl as impl - if ("User", impl.User) in inspect.getmembers(impl): - TeamBase.__bases__ = (impl.User,) + TeamBase.__bases__ = (impl.User,) if m is not None: self.fromJson(m) @@ -1099,6 +1070,7 @@ def __init__(self, m=None): super().__init__(m) def fromJson(self, m): + import tercen.model.impl as impl super().fromJson(m) self.subKind = m.get(Vocabulary.SUBKIND) if self.subKind is None and m.get(Vocabulary.KIND) != Vocabulary.Team_CLASS: @@ -1106,9 +1078,10 @@ def fromJson(self, m): @classmethod def createFromJson(cls, m): + import tercen.model.impl as impl kind = m.get(Vocabulary.KIND) if kind == Vocabulary.Team_CLASS: - return Team(m) + return impl.Team(m) raise ValueError("bad kind : " + kind + " for class Team in createFromJson") @@ -1122,16 +1095,10 @@ def toJson(self): return m -class Team(TeamBase): - def __init__(self, m=None): - super().__init__(m) - - -class PropertyBase(SciObject): +class PropertyBase: def __init__(self, m=None): import tercen.model.impl as impl - if ("SciObject", impl.SciObject) in inspect.getmembers(impl): - PropertyBase.__bases__ = (impl.SciObject,) + PropertyBase.__bases__ = (impl.SciObject,) if m is None: super().__init__(m) self.name = "" @@ -1140,6 +1107,7 @@ def __init__(self, m=None): self.fromJson(m) def fromJson(self, m): + import tercen.model.impl as impl super().fromJson(m) self.subKind = m.get(Vocabulary.SUBKIND) if self.subKind is None and m.get(Vocabulary.KIND) != Vocabulary.Property_CLASS: @@ -1149,21 +1117,22 @@ def fromJson(self, m): @classmethod def createFromJson(cls, m): + import tercen.model.impl as impl kind = m.get(Vocabulary.KIND) if kind == Vocabulary.Property_CLASS: - return Property(m) + return impl.Property(m) if kind == Vocabulary.EnumeratedProperty_CLASS: - return EnumeratedProperty(m) + return impl.EnumeratedProperty(m) if kind == Vocabulary.FactorsProperty_CLASS: - return FactorsProperty(m) + return impl.FactorsProperty(m) if kind == Vocabulary.FormulaProperty_CLASS: - return FormulaProperty(m) + return impl.FormulaProperty(m) if kind == Vocabulary.DoubleProperty_CLASS: - return DoubleProperty(m) + return impl.DoubleProperty(m) if kind == Vocabulary.StringProperty_CLASS: - return StringProperty(m) + return impl.StringProperty(m) if kind == Vocabulary.BooleanProperty_CLASS: - return BooleanProperty(m) + return impl.BooleanProperty(m) raise ValueError("bad kind : " + kind + " for class Property in createFromJson") @@ -1179,16 +1148,10 @@ def toJson(self): return m -class Property(PropertyBase): - def __init__(self, m=None): - super().__init__(m) - - -class DoublePropertyBase(Property): +class DoublePropertyBase: def __init__(self, m=None): import tercen.model.impl as impl - if ("Property", impl.Property) in inspect.getmembers(impl): - DoublePropertyBase.__bases__ = (impl.Property,) + DoublePropertyBase.__bases__ = (impl.Property,) if m is None: super().__init__(m) self.defaultValue = 0.0 @@ -1196,6 +1159,7 @@ def __init__(self, m=None): self.fromJson(m) def fromJson(self, m): + import tercen.model.impl as impl super().fromJson(m) self.subKind = m.get(Vocabulary.SUBKIND) if self.subKind is None and m.get(Vocabulary.KIND) != Vocabulary.DoubleProperty_CLASS: @@ -1204,9 +1168,10 @@ def fromJson(self, m): @classmethod def createFromJson(cls, m): + import tercen.model.impl as impl kind = m.get(Vocabulary.KIND) if kind == Vocabulary.DoubleProperty_CLASS: - return DoubleProperty(m) + return impl.DoubleProperty(m) raise ValueError("bad kind : " + kind + " for class DoubleProperty in createFromJson") @@ -1221,43 +1186,39 @@ def toJson(self): return m -class DoubleProperty(DoublePropertyBase): - def __init__(self, m=None): - super().__init__(m) - - -class RectangleBase(SciObject): +class RectangleBase: def __init__(self, m=None): import tercen.model.impl as impl - if ("SciObject", impl.SciObject) in inspect.getmembers(impl): - RectangleBase.__bases__ = (impl.SciObject,) + RectangleBase.__bases__ = (impl.SciObject,) if m is None: super().__init__(m) - self.extent = Point() - self.topLeft = Point() + self.extent = impl.Point() + self.topLeft = impl.Point() else: self.fromJson(m) def fromJson(self, m): + import tercen.model.impl as impl super().fromJson(m) self.subKind = m.get(Vocabulary.SUBKIND) if self.subKind is None and m.get(Vocabulary.KIND) != Vocabulary.Rectangle_CLASS: self.subKind = m.get(Vocabulary.KIND) if m.get(Vocabulary.extent_OP) is None: - self.extent = Point() + self.extent = impl.Point() else: self.extent = PointBase.createFromJson(m.get(Vocabulary.extent_OP)) if m.get(Vocabulary.topLeft_OP) is None: - self.topLeft = Point() + self.topLeft = impl.Point() else: self.topLeft = PointBase.createFromJson( m.get(Vocabulary.topLeft_OP)) @classmethod def createFromJson(cls, m): + import tercen.model.impl as impl kind = m.get(Vocabulary.KIND) if kind == Vocabulary.Rectangle_CLASS: - return Rectangle(m) + return impl.Rectangle(m) raise ValueError("bad kind : " + kind + " for class Rectangle in createFromJson") @@ -1273,16 +1234,10 @@ def toJson(self): return m -class Rectangle(RectangleBase): - def __init__(self, m=None): - super().__init__(m) - - -class StateBase(SciObject): +class StateBase: def __init__(self, m=None): import tercen.model.impl as impl - if ("SciObject", impl.SciObject) in inspect.getmembers(impl): - StateBase.__bases__ = (impl.SciObject,) + StateBase.__bases__ = (impl.SciObject,) if m is not None: self.fromJson(m) @@ -1290,6 +1245,7 @@ def __init__(self, m=None): super().__init__(m) def fromJson(self, m): + import tercen.model.impl as impl super().fromJson(m) self.subKind = m.get(Vocabulary.SUBKIND) if self.subKind is None and m.get(Vocabulary.KIND) != Vocabulary.State_CLASS: @@ -1297,23 +1253,24 @@ def fromJson(self, m): @classmethod def createFromJson(cls, m): + import tercen.model.impl as impl kind = m.get(Vocabulary.KIND) if kind == Vocabulary.State_CLASS: - return State(m) + return impl.State(m) if kind == Vocabulary.RunningState_CLASS: - return RunningState(m) + return impl.RunningState(m) if kind == Vocabulary.RunningDependentState_CLASS: - return RunningDependentState(m) + return impl.RunningDependentState(m) if kind == Vocabulary.FailedState_CLASS: - return FailedState(m) + return impl.FailedState(m) if kind == Vocabulary.CanceledState_CLASS: - return CanceledState(m) + return impl.CanceledState(m) if kind == Vocabulary.DoneState_CLASS: - return DoneState(m) + return impl.DoneState(m) if kind == Vocabulary.InitState_CLASS: - return InitState(m) + return impl.InitState(m) if kind == Vocabulary.PendingState_CLASS: - return PendingState(m) + return impl.PendingState(m) raise ValueError("bad kind : " + kind + " for class State in createFromJson") @@ -1327,16 +1284,10 @@ def toJson(self): return m -class State(StateBase): - def __init__(self, m=None): - super().__init__(m) - - -class RunningStateBase(State): +class RunningStateBase: def __init__(self, m=None): import tercen.model.impl as impl - if ("State", impl.State) in inspect.getmembers(impl): - RunningStateBase.__bases__ = (impl.State,) + RunningStateBase.__bases__ = (impl.State,) if m is not None: self.fromJson(m) @@ -1344,6 +1295,7 @@ def __init__(self, m=None): super().__init__(m) def fromJson(self, m): + import tercen.model.impl as impl super().fromJson(m) self.subKind = m.get(Vocabulary.SUBKIND) if self.subKind is None and m.get(Vocabulary.KIND) != Vocabulary.RunningState_CLASS: @@ -1351,9 +1303,10 @@ def fromJson(self, m): @classmethod def createFromJson(cls, m): + import tercen.model.impl as impl kind = m.get(Vocabulary.KIND) if kind == Vocabulary.RunningState_CLASS: - return RunningState(m) + return impl.RunningState(m) raise ValueError("bad kind : " + kind + " for class RunningState in createFromJson") @@ -1367,16 +1320,10 @@ def toJson(self): return m -class RunningState(RunningStateBase): - def __init__(self, m=None): - super().__init__(m) - - -class RelationBase(IdObject): +class RelationBase: def __init__(self, m=None): import tercen.model.impl as impl - if ("IdObject", impl.IdObject) in inspect.getmembers(impl): - RelationBase.__bases__ = (impl.IdObject,) + RelationBase.__bases__ = (impl.IdObject,) if m is not None: self.fromJson(m) @@ -1384,6 +1331,7 @@ def __init__(self, m=None): super().__init__(m) def fromJson(self, m): + import tercen.model.impl as impl super().fromJson(m) self.subKind = m.get(Vocabulary.SUBKIND) if self.subKind is None and m.get(Vocabulary.KIND) != Vocabulary.Relation_CLASS: @@ -1391,31 +1339,32 @@ def fromJson(self, m): @classmethod def createFromJson(cls, m): + import tercen.model.impl as impl kind = m.get(Vocabulary.KIND) if kind == Vocabulary.Relation_CLASS: - return Relation(m) + return impl.Relation(m) if kind == Vocabulary.TableRelation_CLASS: - return TableRelation(m) + return impl.TableRelation(m) if kind == Vocabulary.WhereRelation_CLASS: - return WhereRelation(m) + return impl.WhereRelation(m) if kind == Vocabulary.DistinctRelation_CLASS: - return DistinctRelation(m) + return impl.DistinctRelation(m) if kind == Vocabulary.ReferenceRelation_CLASS: - return ReferenceRelation(m) + return impl.ReferenceRelation(m) if kind == Vocabulary.InMemoryRelation_CLASS: - return InMemoryRelation(m) + return impl.InMemoryRelation(m) if kind == Vocabulary.RenameRelation_CLASS: - return RenameRelation(m) + return impl.RenameRelation(m) if kind == Vocabulary.UnionRelation_CLASS: - return UnionRelation(m) + return impl.UnionRelation(m) if kind == Vocabulary.SimpleRelation_CLASS: - return SimpleRelation(m) + return impl.SimpleRelation(m) if kind == Vocabulary.GatherRelation_CLASS: - return GatherRelation(m) + return impl.GatherRelation(m) if kind == Vocabulary.CompositeRelation_CLASS: - return CompositeRelation(m) + return impl.CompositeRelation(m) if kind == Vocabulary.GroupByRelation_CLASS: - return GroupByRelation(m) + return impl.GroupByRelation(m) raise ValueError("bad kind : " + kind + " for class Relation in createFromJson") @@ -1429,44 +1378,40 @@ def toJson(self): return m -class Relation(RelationBase): - def __init__(self, m=None): - super().__init__(m) - - -class WhereRelationBase(Relation): +class WhereRelationBase: def __init__(self, m=None): import tercen.model.impl as impl - if ("Relation", impl.Relation) in inspect.getmembers(impl): - WhereRelationBase.__bases__ = (impl.Relation,) + WhereRelationBase.__bases__ = (impl.Relation,) if m is None: super().__init__(m) - self.relation = Relation() - self.filters = Filters() + self.relation = impl.Relation() + self.filters = impl.Filters() else: self.fromJson(m) def fromJson(self, m): + import tercen.model.impl as impl super().fromJson(m) self.subKind = m.get(Vocabulary.SUBKIND) if self.subKind is None and m.get(Vocabulary.KIND) != Vocabulary.WhereRelation_CLASS: self.subKind = m.get(Vocabulary.KIND) if m.get(Vocabulary.relation_OP) is None: - self.relation = Relation() + self.relation = impl.Relation() else: self.relation = RelationBase.createFromJson( m.get(Vocabulary.relation_OP)) if m.get(Vocabulary.filters_OP) is None: - self.filters = Filters() + self.filters = impl.Filters() else: self.filters = FiltersBase.createFromJson( m.get(Vocabulary.filters_OP)) @classmethod def createFromJson(cls, m): + import tercen.model.impl as impl kind = m.get(Vocabulary.KIND) if kind == Vocabulary.WhereRelation_CLASS: - return WhereRelation(m) + return impl.WhereRelation(m) raise ValueError("bad kind : " + kind + " for class WhereRelation in createFromJson") @@ -1482,16 +1427,10 @@ def toJson(self): return m -class WhereRelation(WhereRelationBase): - def __init__(self, m=None): - super().__init__(m) - - -class ProfileBase(SciObject): +class ProfileBase: def __init__(self, m=None): import tercen.model.impl as impl - if ("SciObject", impl.SciObject) in inspect.getmembers(impl): - ProfileBase.__bases__ = (impl.SciObject,) + ProfileBase.__bases__ = (impl.SciObject,) if m is None: super().__init__(m) self.name = "" @@ -1499,6 +1438,7 @@ def __init__(self, m=None): self.fromJson(m) def fromJson(self, m): + import tercen.model.impl as impl super().fromJson(m) self.subKind = m.get(Vocabulary.SUBKIND) if self.subKind is None and m.get(Vocabulary.KIND) != Vocabulary.Profile_CLASS: @@ -1507,19 +1447,20 @@ def fromJson(self, m): @classmethod def createFromJson(cls, m): + import tercen.model.impl as impl kind = m.get(Vocabulary.KIND) if kind == Vocabulary.Profile_CLASS: - return Profile(m) + return impl.Profile(m) if kind == Vocabulary.StorageProfile_CLASS: - return StorageProfile(m) + return impl.StorageProfile(m) if kind == Vocabulary.RunProfile_CLASS: - return RunProfile(m) + return impl.RunProfile(m) if kind == Vocabulary.CpuTimeProfile_CLASS: - return CpuTimeProfile(m) + return impl.CpuTimeProfile(m) if kind == Vocabulary.TableProfile_CLASS: - return TableProfile(m) + return impl.TableProfile(m) if kind == Vocabulary.ApiCallProfile_CLASS: - return ApiCallProfile(m) + return impl.ApiCallProfile(m) raise ValueError("bad kind : " + kind + " for class Profile in createFromJson") @@ -1534,16 +1475,10 @@ def toJson(self): return m -class Profile(ProfileBase): - def __init__(self, m=None): - super().__init__(m) - - -class StorageProfileBase(Profile): +class StorageProfileBase: def __init__(self, m=None): import tercen.model.impl as impl - if ("Profile", impl.Profile) in inspect.getmembers(impl): - StorageProfileBase.__bases__ = (impl.Profile,) + StorageProfileBase.__bases__ = (impl.Profile,) if m is None: super().__init__(m) self.size = 0 @@ -1551,6 +1486,7 @@ def __init__(self, m=None): self.fromJson(m) def fromJson(self, m): + import tercen.model.impl as impl super().fromJson(m) self.subKind = m.get(Vocabulary.SUBKIND) if self.subKind is None and m.get(Vocabulary.KIND) != Vocabulary.StorageProfile_CLASS: @@ -1559,9 +1495,10 @@ def fromJson(self, m): @classmethod def createFromJson(cls, m): + import tercen.model.impl as impl kind = m.get(Vocabulary.KIND) if kind == Vocabulary.StorageProfile_CLASS: - return StorageProfile(m) + return impl.StorageProfile(m) raise ValueError("bad kind : " + kind + " for class StorageProfile in createFromJson") @@ -1576,16 +1513,10 @@ def toJson(self): return m -class StorageProfile(StorageProfileBase): - def __init__(self, m=None): - super().__init__(m) - - -class ResourceSummaryBase(SciObject): +class ResourceSummaryBase: def __init__(self, m=None): import tercen.model.impl as impl - if ("SciObject", impl.SciObject) in inspect.getmembers(impl): - ResourceSummaryBase.__bases__ = (impl.SciObject,) + ResourceSummaryBase.__bases__ = (impl.SciObject,) if m is None: super().__init__(m) self.storage = 0.0 @@ -1596,6 +1527,7 @@ def __init__(self, m=None): self.fromJson(m) def fromJson(self, m): + import tercen.model.impl as impl super().fromJson(m) self.subKind = m.get(Vocabulary.SUBKIND) if self.subKind is None and m.get(Vocabulary.KIND) != Vocabulary.ResourceSummary_CLASS: @@ -1607,9 +1539,10 @@ def fromJson(self, m): @classmethod def createFromJson(cls, m): + import tercen.model.impl as impl kind = m.get(Vocabulary.KIND) if kind == Vocabulary.ResourceSummary_CLASS: - return ResourceSummary(m) + return impl.ResourceSummary(m) raise ValueError("bad kind : " + kind + " for class ResourceSummary in createFromJson") @@ -1627,27 +1560,22 @@ def toJson(self): return m -class ResourceSummary(ResourceSummaryBase): - def __init__(self, m=None): - super().__init__(m) - - -class BillingInfoBase(SciObject): +class BillingInfoBase: def __init__(self, m=None): import tercen.model.impl as impl - if ("SciObject", impl.SciObject) in inspect.getmembers(impl): - BillingInfoBase.__bases__ = (impl.SciObject,) + BillingInfoBase.__bases__ = (impl.SciObject,) if m is None: super().__init__(m) self.firstName = "" self.lastName = "" self.companyName = "" - self.taxId = TaxId() - self.address = Address() + self.taxId = impl.TaxId() + self.address = impl.Address() else: self.fromJson(m) def fromJson(self, m): + import tercen.model.impl as impl super().fromJson(m) self.subKind = m.get(Vocabulary.SUBKIND) if self.subKind is None and m.get(Vocabulary.KIND) != Vocabulary.BillingInfo_CLASS: @@ -1656,20 +1584,21 @@ def fromJson(self, m): self.lastName = m[Vocabulary.lastName_DP] self.companyName = m[Vocabulary.companyName_DP] if m.get(Vocabulary.taxId_OP) is None: - self.taxId = TaxId() + self.taxId = impl.TaxId() else: self.taxId = TaxIdBase.createFromJson(m.get(Vocabulary.taxId_OP)) if m.get(Vocabulary.address_OP) is None: - self.address = Address() + self.address = impl.Address() else: self.address = AddressBase.createFromJson( m.get(Vocabulary.address_OP)) @classmethod def createFromJson(cls, m): + import tercen.model.impl as impl kind = m.get(Vocabulary.KIND) if kind == Vocabulary.BillingInfo_CLASS: - return BillingInfo(m) + return impl.BillingInfo(m) raise ValueError("bad kind : " + kind + " for class BillingInfo in createFromJson") @@ -1688,51 +1617,47 @@ def toJson(self): return m -class BillingInfo(BillingInfoBase): - def __init__(self, m=None): - super().__init__(m) - - -class EventBase(PersistentObject): +class EventBase: def __init__(self, m=None): import tercen.model.impl as impl - if ("PersistentObject", impl.PersistentObject) in inspect.getmembers(impl): - EventBase.__bases__ = (impl.PersistentObject,) + EventBase.__bases__ = (impl.PersistentObject,) if m is None: super().__init__(m) - self.date = Date() + self.date = impl.Date() else: self.fromJson(m) def fromJson(self, m): + import tercen.model.impl as impl super().fromJson(m) self.subKind = m.get(Vocabulary.SUBKIND) if self.subKind is None and m.get(Vocabulary.KIND) != Vocabulary.Event_CLASS: self.subKind = m.get(Vocabulary.KIND) if m.get(Vocabulary.date_OP) is None: - self.date = Date() + self.date = impl.Date() else: self.date = DateBase.createFromJson(m.get(Vocabulary.date_OP)) @classmethod def createFromJson(cls, m): + import tercen.model.impl as impl kind = m.get(Vocabulary.KIND) if kind == Vocabulary.Event_CLASS: - return Event(m) + return impl.Event(m) if kind == Vocabulary.TaskLogEvent_CLASS: - return TaskLogEvent(m) + return impl.TaskLogEvent(m) if kind == Vocabulary.TaskProgressEvent_CLASS: - return TaskProgressEvent(m) + return impl.TaskProgressEvent(m) if kind == Vocabulary.TaskDataEvent_CLASS: - return TaskDataEvent(m) + return impl.TaskDataEvent(m) if kind == Vocabulary.TaskStateEvent_CLASS: - return TaskStateEvent(m) + return impl.TaskStateEvent(m) if kind == Vocabulary.PatchRecords_CLASS: - return PatchRecords(m) + return impl.PatchRecords(m) if kind == Vocabulary.TaskEvent_CLASS: - return TaskEvent(m) + return impl.TaskEvent(m) if kind == Vocabulary.GenericEvent_CLASS: - return GenericEvent(m) + return impl.GenericEvent(m) raise ValueError("bad kind : " + kind + " for class Event in createFromJson") @@ -1747,16 +1672,10 @@ def toJson(self): return m -class Event(EventBase): - def __init__(self, m=None): - super().__init__(m) - - -class PatchRecordsBase(Event): +class PatchRecordsBase: def __init__(self, m=None): import tercen.model.impl as impl - if ("Event", impl.Event) in inspect.getmembers(impl): - PatchRecordsBase.__bases__ = (impl.Event,) + PatchRecordsBase.__bases__ = (impl.Event,) if m is None: super().__init__(m) self.u = "" @@ -1770,6 +1689,7 @@ def __init__(self, m=None): self.fromJson(m) def fromJson(self, m): + import tercen.model.impl as impl super().fromJson(m) self.subKind = m.get(Vocabulary.SUBKIND) if self.subKind is None and m.get(Vocabulary.KIND) != Vocabulary.PatchRecords_CLASS: @@ -1789,9 +1709,10 @@ def fromJson(self, m): @classmethod def createFromJson(cls, m): + import tercen.model.impl as impl kind = m.get(Vocabulary.KIND) if kind == Vocabulary.PatchRecords_CLASS: - return PatchRecords(m) + return impl.PatchRecords(m) raise ValueError("bad kind : " + kind + " for class PatchRecords in createFromJson") @@ -1812,16 +1733,10 @@ def toJson(self): return m -class PatchRecords(PatchRecordsBase): - def __init__(self, m=None): - super().__init__(m) - - -class GarbageObjectBase(PersistentObject): +class GarbageObjectBase: def __init__(self, m=None): import tercen.model.impl as impl - if ("PersistentObject", impl.PersistentObject) in inspect.getmembers(impl): - GarbageObjectBase.__bases__ = (impl.PersistentObject,) + GarbageObjectBase.__bases__ = (impl.PersistentObject,) if m is not None: self.fromJson(m) @@ -1829,6 +1744,7 @@ def __init__(self, m=None): super().__init__(m) def fromJson(self, m): + import tercen.model.impl as impl super().fromJson(m) self.subKind = m.get(Vocabulary.SUBKIND) if self.subKind is None and m.get(Vocabulary.KIND) != Vocabulary.GarbageObject_CLASS: @@ -1836,13 +1752,14 @@ def fromJson(self, m): @classmethod def createFromJson(cls, m): + import tercen.model.impl as impl kind = m.get(Vocabulary.KIND) if kind == Vocabulary.GarbageObject_CLASS: - return GarbageObject(m) + return impl.GarbageObject(m) if kind == Vocabulary.GarbageTasks_CLASS: - return GarbageTasks(m) + return impl.GarbageTasks(m) if kind == Vocabulary.GarbageTasks2_CLASS: - return GarbageTasks2(m) + return impl.GarbageTasks2(m) raise ValueError("bad kind : " + kind + " for class GarbageObject in createFromJson") @@ -1856,16 +1773,10 @@ def toJson(self): return m -class GarbageObject(GarbageObjectBase): - def __init__(self, m=None): - super().__init__(m) - - -class GarbageTasksBase(GarbageObject): +class GarbageTasksBase: def __init__(self, m=None): import tercen.model.impl as impl - if ("GarbageObject", impl.GarbageObject) in inspect.getmembers(impl): - GarbageTasksBase.__bases__ = (impl.GarbageObject,) + GarbageTasksBase.__bases__ = (impl.GarbageObject,) if m is None: super().__init__(m) self.workflowId = "" @@ -1876,6 +1787,7 @@ def __init__(self, m=None): self.fromJson(m) def fromJson(self, m): + import tercen.model.impl as impl super().fromJson(m) self.subKind = m.get(Vocabulary.SUBKIND) if self.subKind is None and m.get(Vocabulary.KIND) != Vocabulary.GarbageTasks_CLASS: @@ -1896,9 +1808,10 @@ def fromJson(self, m): @classmethod def createFromJson(cls, m): + import tercen.model.impl as impl kind = m.get(Vocabulary.KIND) if kind == Vocabulary.GarbageTasks_CLASS: - return GarbageTasks(m) + return impl.GarbageTasks(m) raise ValueError("bad kind : " + kind + " for class GarbageTasks in createFromJson") @@ -1916,16 +1829,10 @@ def toJson(self): return m -class GarbageTasks(GarbageTasksBase): - def __init__(self, m=None): - super().__init__(m) - - -class VersionBase(SciObject): +class VersionBase: def __init__(self, m=None): import tercen.model.impl as impl - if ("SciObject", impl.SciObject) in inspect.getmembers(impl): - VersionBase.__bases__ = (impl.SciObject,) + VersionBase.__bases__ = (impl.SciObject,) if m is None: super().__init__(m) self.major = 0 @@ -1939,6 +1846,7 @@ def __init__(self, m=None): self.fromJson(m) def fromJson(self, m): + import tercen.model.impl as impl super().fromJson(m) self.subKind = m.get(Vocabulary.SUBKIND) if self.subKind is None and m.get(Vocabulary.KIND) != Vocabulary.Version_CLASS: @@ -1956,9 +1864,10 @@ def fromJson(self, m): @classmethod def createFromJson(cls, m): + import tercen.model.impl as impl kind = m.get(Vocabulary.KIND) if kind == Vocabulary.Version_CLASS: - return Version(m) + return impl.Version(m) raise ValueError("bad kind : " + kind + " for class Version in createFromJson") @@ -1979,16 +1888,10 @@ def toJson(self): return m -class Version(VersionBase): - def __init__(self, m=None): - super().__init__(m) - - -class FiltersBase(SciObject): +class FiltersBase: def __init__(self, m=None): import tercen.model.impl as impl - if ("SciObject", impl.SciObject) in inspect.getmembers(impl): - FiltersBase.__bases__ = (impl.SciObject,) + FiltersBase.__bases__ = (impl.SciObject,) if m is None: super().__init__(m) self.removeNaN = True @@ -1997,6 +1900,7 @@ def __init__(self, m=None): self.fromJson(m) def fromJson(self, m): + import tercen.model.impl as impl super().fromJson(m) self.subKind = m.get(Vocabulary.SUBKIND) if self.subKind is None and m.get(Vocabulary.KIND) != Vocabulary.Filters_CLASS: @@ -2011,9 +1915,10 @@ def fromJson(self, m): @classmethod def createFromJson(cls, m): + import tercen.model.impl as impl kind = m.get(Vocabulary.KIND) if kind == Vocabulary.Filters_CLASS: - return Filters(m) + return impl.Filters(m) raise ValueError("bad kind : " + kind + " for class Filters in createFromJson") @@ -2030,50 +1935,46 @@ def toJson(self): return m -class Filters(FiltersBase): - def __init__(self, m=None): - super().__init__(m) - - -class ChartBase(SciObject): +class ChartBase: def __init__(self, m=None): import tercen.model.impl as impl - if ("SciObject", impl.SciObject) in inspect.getmembers(impl): - ChartBase.__bases__ = (impl.SciObject,) + ChartBase.__bases__ = (impl.SciObject,) if m is None: super().__init__(m) self.name = "" - self.properties = Properties() + self.properties = impl.Properties() else: self.fromJson(m) def fromJson(self, m): + import tercen.model.impl as impl super().fromJson(m) self.subKind = m.get(Vocabulary.SUBKIND) if self.subKind is None and m.get(Vocabulary.KIND) != Vocabulary.Chart_CLASS: self.subKind = m.get(Vocabulary.KIND) self.name = m[Vocabulary.name_DP] if m.get(Vocabulary.properties_OP) is None: - self.properties = Properties() + self.properties = impl.Properties() else: self.properties = PropertiesBase.createFromJson( m.get(Vocabulary.properties_OP)) @classmethod def createFromJson(cls, m): + import tercen.model.impl as impl kind = m.get(Vocabulary.KIND) if kind == Vocabulary.Chart_CLASS: - return Chart(m) + return impl.Chart(m) if kind == Vocabulary.ChartLine_CLASS: - return ChartLine(m) + return impl.ChartLine(m) if kind == Vocabulary.ChartPoint_CLASS: - return ChartPoint(m) + return impl.ChartPoint(m) if kind == Vocabulary.ChartHeatmap_CLASS: - return ChartHeatmap(m) + return impl.ChartHeatmap(m) if kind == Vocabulary.ChartBar_CLASS: - return ChartBar(m) + return impl.ChartBar(m) if kind == Vocabulary.ChartSize_CLASS: - return ChartSize(m) + return impl.ChartSize(m) raise ValueError("bad kind : " + kind + " for class Chart in createFromJson") @@ -2089,16 +1990,10 @@ def toJson(self): return m -class Chart(ChartBase): - def __init__(self, m=None): - super().__init__(m) - - -class ChartHeatmapBase(Chart): +class ChartHeatmapBase: def __init__(self, m=None): import tercen.model.impl as impl - if ("Chart", impl.Chart) in inspect.getmembers(impl): - ChartHeatmapBase.__bases__ = (impl.Chart,) + ChartHeatmapBase.__bases__ = (impl.Chart,) if m is not None: self.fromJson(m) @@ -2106,6 +2001,7 @@ def __init__(self, m=None): super().__init__(m) def fromJson(self, m): + import tercen.model.impl as impl super().fromJson(m) self.subKind = m.get(Vocabulary.SUBKIND) if self.subKind is None and m.get(Vocabulary.KIND) != Vocabulary.ChartHeatmap_CLASS: @@ -2113,9 +2009,10 @@ def fromJson(self, m): @classmethod def createFromJson(cls, m): + import tercen.model.impl as impl kind = m.get(Vocabulary.KIND) if kind == Vocabulary.ChartHeatmap_CLASS: - return ChartHeatmap(m) + return impl.ChartHeatmap(m) raise ValueError("bad kind : " + kind + " for class ChartHeatmap in createFromJson") @@ -2129,13 +2026,9 @@ def toJson(self): return m -class ChartHeatmap(ChartHeatmapBase): - def __init__(self, m=None): - super().__init__(m) - - -class StatisticNodeBase(BaseObject): +class StatisticNodeBase: def __init__(self, m=None): + import tercen.model.impl as impl if m is None: super().__init__(m) self.name = "" @@ -2144,6 +2037,7 @@ def __init__(self, m=None): self.fromJson(m) def fromJson(self, m): + import tercen.model.impl as impl super().fromJson(m) self.subKind = m.get(Vocabulary.SUBKIND) if self.subKind is None and m.get(Vocabulary.KIND) != Vocabulary.StatisticNode_CLASS: @@ -2158,9 +2052,10 @@ def fromJson(self, m): @classmethod def createFromJson(cls, m): + import tercen.model.impl as impl kind = m.get(Vocabulary.KIND) if kind == Vocabulary.StatisticNode_CLASS: - return StatisticNode(m) + return impl.StatisticNode(m) raise ValueError("bad kind : " + kind + " for class StatisticNode in createFromJson") @@ -2176,31 +2071,26 @@ def toJson(self): return m -class StatisticNode(StatisticNodeBase): - def __init__(self, m=None): - super().__init__(m) - - -class CubeQueryBase(SciObject): +class CubeQueryBase: def __init__(self, m=None): import tercen.model.impl as impl - if ("SciObject", impl.SciObject) in inspect.getmembers(impl): - CubeQueryBase.__bases__ = (impl.SciObject,) + CubeQueryBase.__bases__ = (impl.SciObject,) if m is None: super().__init__(m) self.qtHash = "" self.columnHash = "" self.rowHash = "" - self.relation = Relation() + self.relation = impl.Relation() self.colColumns = list() self.rowColumns = list() self.axisQueries = list() - self.filters = Filters() - self.operatorSettings = OperatorSettings() + self.filters = impl.Filters() + self.operatorSettings = impl.OperatorSettings() else: self.fromJson(m) def fromJson(self, m): + import tercen.model.impl as impl super().fromJson(m) self.subKind = m.get(Vocabulary.SUBKIND) if self.subKind is None and m.get(Vocabulary.KIND) != Vocabulary.CubeQuery_CLASS: @@ -2209,7 +2099,7 @@ def fromJson(self, m): self.columnHash = m[Vocabulary.columnHash_DP] self.rowHash = m[Vocabulary.rowHash_DP] if m.get(Vocabulary.relation_OP) is None: - self.relation = Relation() + self.relation = impl.Relation() else: self.relation = RelationBase.createFromJson( m.get(Vocabulary.relation_OP)) @@ -2232,21 +2122,22 @@ def fromJson(self, m): for o in m.get(Vocabulary.axisQueries_OP): self.axisQueries.append(CubeAxisQueryBase.createFromJson(o)) if m.get(Vocabulary.filters_OP) is None: - self.filters = Filters() + self.filters = impl.Filters() else: self.filters = FiltersBase.createFromJson( m.get(Vocabulary.filters_OP)) if m.get(Vocabulary.operatorSettings_OP) is None: - self.operatorSettings = OperatorSettings() + self.operatorSettings = impl.OperatorSettings() else: self.operatorSettings = OperatorSettingsBase.createFromJson( m.get(Vocabulary.operatorSettings_OP)) @classmethod def createFromJson(cls, m): + import tercen.model.impl as impl kind = m.get(Vocabulary.KIND) if kind == Vocabulary.CubeQuery_CLASS: - return CubeQuery(m) + return impl.CubeQuery(m) raise ValueError("bad kind : " + kind + " for class CubeQuery in createFromJson") @@ -2272,42 +2163,38 @@ def toJson(self): return m -class CubeQuery(CubeQueryBase): - def __init__(self, m=None): - super().__init__(m) - - -class RLibraryBase(Document): +class RLibraryBase: def __init__(self, m=None): import tercen.model.impl as impl - if ("Document", impl.Document) in inspect.getmembers(impl): - RLibraryBase.__bases__ = (impl.Document,) + RLibraryBase.__bases__ = (impl.Document,) if m is None: super().__init__(m) - self.rDescription = RDescription() + self.rDescription = impl.RDescription() else: self.fromJson(m) def fromJson(self, m): + import tercen.model.impl as impl super().fromJson(m) self.subKind = m.get(Vocabulary.SUBKIND) if self.subKind is None and m.get(Vocabulary.KIND) != Vocabulary.RLibrary_CLASS: self.subKind = m.get(Vocabulary.KIND) if m.get(Vocabulary.rDescription_OP) is None: - self.rDescription = RDescription() + self.rDescription = impl.RDescription() else: self.rDescription = RDescriptionBase.createFromJson( m.get(Vocabulary.rDescription_OP)) @classmethod def createFromJson(cls, m): + import tercen.model.impl as impl kind = m.get(Vocabulary.KIND) if kind == Vocabulary.RLibrary_CLASS: - return RLibrary(m) + return impl.RLibrary(m) if kind == Vocabulary.RSourceLibrary_CLASS: - return RSourceLibrary(m) + return impl.RSourceLibrary(m) if kind == Vocabulary.RenvInstalledLibrary_CLASS: - return RenvInstalledLibrary(m) + return impl.RenvInstalledLibrary(m) raise ValueError("bad kind : " + kind + " for class RLibrary in createFromJson") @@ -2322,16 +2209,10 @@ def toJson(self): return m -class RLibrary(RLibraryBase): - def __init__(self, m=None): - super().__init__(m) - - -class FilterTopExprBase(SciObject): +class FilterTopExprBase: def __init__(self, m=None): import tercen.model.impl as impl - if ("SciObject", impl.SciObject) in inspect.getmembers(impl): - FilterTopExprBase.__bases__ = (impl.SciObject,) + FilterTopExprBase.__bases__ = (impl.SciObject,) if m is not None: self.fromJson(m) @@ -2339,6 +2220,7 @@ def __init__(self, m=None): super().__init__(m) def fromJson(self, m): + import tercen.model.impl as impl super().fromJson(m) self.subKind = m.get(Vocabulary.SUBKIND) if self.subKind is None and m.get(Vocabulary.KIND) != Vocabulary.FilterTopExpr_CLASS: @@ -2346,17 +2228,18 @@ def fromJson(self, m): @classmethod def createFromJson(cls, m): + import tercen.model.impl as impl kind = m.get(Vocabulary.KIND) if kind == Vocabulary.FilterTopExpr_CLASS: - return FilterTopExpr(m) + return impl.FilterTopExpr(m) if kind == Vocabulary.NamedFilter_CLASS: - return NamedFilter(m) + return impl.NamedFilter(m) if kind == Vocabulary.FilterExpr2d_CLASS: - return FilterExpr2d(m) + return impl.FilterExpr2d(m) if kind == Vocabulary.Filter_CLASS: - return Filter(m) + return impl.Filter(m) if kind == Vocabulary.FilterExpr_CLASS: - return FilterExpr(m) + return impl.FilterExpr(m) raise ValueError("bad kind : " + kind + " for class FilterTopExpr in createFromJson") @@ -2370,16 +2253,10 @@ def toJson(self): return m -class FilterTopExpr(FilterTopExprBase): - def __init__(self, m=None): - super().__init__(m) - - -class FilterBase(FilterTopExpr): +class FilterBase: def __init__(self, m=None): import tercen.model.impl as impl - if ("FilterTopExpr", impl.FilterTopExpr) in inspect.getmembers(impl): - FilterBase.__bases__ = (impl.FilterTopExpr,) + FilterBase.__bases__ = (impl.FilterTopExpr,) if m is None: super().__init__(m) self.logical = "" @@ -2389,6 +2266,7 @@ def __init__(self, m=None): self.fromJson(m) def fromJson(self, m): + import tercen.model.impl as impl super().fromJson(m) self.subKind = m.get(Vocabulary.SUBKIND) if self.subKind is None and m.get(Vocabulary.KIND) != Vocabulary.Filter_CLASS: @@ -2404,11 +2282,12 @@ def fromJson(self, m): @classmethod def createFromJson(cls, m): + import tercen.model.impl as impl kind = m.get(Vocabulary.KIND) if kind == Vocabulary.Filter_CLASS: - return Filter(m) + return impl.Filter(m) if kind == Vocabulary.NamedFilter_CLASS: - return NamedFilter(m) + return impl.NamedFilter(m) raise ValueError("bad kind : " + kind + " for class Filter in createFromJson") @@ -2426,28 +2305,23 @@ def toJson(self): return m -class Filter(FilterBase): - def __init__(self, m=None): - super().__init__(m) - - -class StepBase(IdObject): +class StepBase: def __init__(self, m=None): import tercen.model.impl as impl - if ("IdObject", impl.IdObject) in inspect.getmembers(impl): - StepBase.__bases__ = (impl.IdObject,) + StepBase.__bases__ = (impl.IdObject,) if m is None: super().__init__(m) self.groupId = "" self.name = "" self.inputs = list() self.outputs = list() - self.rectangle = Rectangle() - self.state = StepState() + self.rectangle = impl.Rectangle() + self.state = impl.StepState() else: self.fromJson(m) def fromJson(self, m): + import tercen.model.impl as impl super().fromJson(m) self.subKind = m.get(Vocabulary.SUBKIND) if self.subKind is None and m.get(Vocabulary.KIND) != Vocabulary.Step_CLASS: @@ -2467,49 +2341,50 @@ def fromJson(self, m): for o in m.get(Vocabulary.outputs_OP): self.outputs.append(OutputPortBase.createFromJson(o)) if m.get(Vocabulary.rectangle_OP) is None: - self.rectangle = Rectangle() + self.rectangle = impl.Rectangle() else: self.rectangle = RectangleBase.createFromJson( m.get(Vocabulary.rectangle_OP)) if m.get(Vocabulary.state_OP) is None: - self.state = StepState() + self.state = impl.StepState() else: self.state = StepStateBase.createFromJson( m.get(Vocabulary.state_OP)) @classmethod def createFromJson(cls, m): + import tercen.model.impl as impl kind = m.get(Vocabulary.KIND) if kind == Vocabulary.Step_CLASS: - return Step(m) + return impl.Step(m) if kind == Vocabulary.DataStep_CLASS: - return DataStep(m) + return impl.DataStep(m) if kind == Vocabulary.MeltStep_CLASS: - return MeltStep(m) + return impl.MeltStep(m) if kind == Vocabulary.JoinStep_CLASS: - return JoinStep(m) + return impl.JoinStep(m) if kind == Vocabulary.WizardStep_CLASS: - return WizardStep(m) + return impl.WizardStep(m) if kind == Vocabulary.CrossTabStep_CLASS: - return CrossTabStep(m) + return impl.CrossTabStep(m) if kind == Vocabulary.GroupStep_CLASS: - return GroupStep(m) + return impl.GroupStep(m) if kind == Vocabulary.InStep_CLASS: - return InStep(m) + return impl.InStep(m) if kind == Vocabulary.OutStep_CLASS: - return OutStep(m) + return impl.OutStep(m) if kind == Vocabulary.TableStep_CLASS: - return TableStep(m) + return impl.TableStep(m) if kind == Vocabulary.NamespaceStep_CLASS: - return NamespaceStep(m) + return impl.NamespaceStep(m) if kind == Vocabulary.RelationStep_CLASS: - return RelationStep(m) + return impl.RelationStep(m) if kind == Vocabulary.ExportStep_CLASS: - return ExportStep(m) + return impl.ExportStep(m) if kind == Vocabulary.ModelStep_CLASS: - return ModelStep(m) + return impl.ModelStep(m) if kind == Vocabulary.ViewStep_CLASS: - return ViewStep(m) + return impl.ViewStep(m) raise ValueError("bad kind : " + kind + " for class Step in createFromJson") @@ -2530,16 +2405,10 @@ def toJson(self): return m -class Step(StepBase): - def __init__(self, m=None): - super().__init__(m) - - -class ModelStepBase(Step): +class ModelStepBase: def __init__(self, m=None): import tercen.model.impl as impl - if ("Step", impl.Step) in inspect.getmembers(impl): - ModelStepBase.__bases__ = (impl.Step,) + ModelStepBase.__bases__ = (impl.Step,) if m is not None: self.fromJson(m) @@ -2547,6 +2416,7 @@ def __init__(self, m=None): super().__init__(m) def fromJson(self, m): + import tercen.model.impl as impl super().fromJson(m) self.subKind = m.get(Vocabulary.SUBKIND) if self.subKind is None and m.get(Vocabulary.KIND) != Vocabulary.ModelStep_CLASS: @@ -2554,33 +2424,34 @@ def fromJson(self, m): @classmethod def createFromJson(cls, m): + import tercen.model.impl as impl kind = m.get(Vocabulary.KIND) if kind == Vocabulary.ModelStep_CLASS: - return ModelStep(m) + return impl.ModelStep(m) if kind == Vocabulary.DataStep_CLASS: - return DataStep(m) + return impl.DataStep(m) if kind == Vocabulary.MeltStep_CLASS: - return MeltStep(m) + return impl.MeltStep(m) if kind == Vocabulary.JoinStep_CLASS: - return JoinStep(m) + return impl.JoinStep(m) if kind == Vocabulary.WizardStep_CLASS: - return WizardStep(m) + return impl.WizardStep(m) if kind == Vocabulary.CrossTabStep_CLASS: - return CrossTabStep(m) + return impl.CrossTabStep(m) if kind == Vocabulary.GroupStep_CLASS: - return GroupStep(m) + return impl.GroupStep(m) if kind == Vocabulary.InStep_CLASS: - return InStep(m) + return impl.InStep(m) if kind == Vocabulary.OutStep_CLASS: - return OutStep(m) + return impl.OutStep(m) if kind == Vocabulary.TableStep_CLASS: - return TableStep(m) + return impl.TableStep(m) if kind == Vocabulary.NamespaceStep_CLASS: - return NamespaceStep(m) + return impl.NamespaceStep(m) if kind == Vocabulary.RelationStep_CLASS: - return RelationStep(m) + return impl.RelationStep(m) if kind == Vocabulary.ExportStep_CLASS: - return ExportStep(m) + return impl.ExportStep(m) raise ValueError("bad kind : " + kind + " for class ModelStep in createFromJson") @@ -2594,16 +2465,10 @@ def toJson(self): return m -class ModelStep(ModelStepBase): - def __init__(self, m=None): - super().__init__(m) - - -class RelationStepBase(ModelStep): +class RelationStepBase: def __init__(self, m=None): import tercen.model.impl as impl - if ("ModelStep", impl.ModelStep) in inspect.getmembers(impl): - RelationStepBase.__bases__ = (impl.ModelStep,) + RelationStepBase.__bases__ = (impl.ModelStep,) if m is not None: self.fromJson(m) @@ -2611,6 +2476,7 @@ def __init__(self, m=None): super().__init__(m) def fromJson(self, m): + import tercen.model.impl as impl super().fromJson(m) self.subKind = m.get(Vocabulary.SUBKIND) if self.subKind is None and m.get(Vocabulary.KIND) != Vocabulary.RelationStep_CLASS: @@ -2618,29 +2484,30 @@ def fromJson(self, m): @classmethod def createFromJson(cls, m): + import tercen.model.impl as impl kind = m.get(Vocabulary.KIND) if kind == Vocabulary.RelationStep_CLASS: - return RelationStep(m) + return impl.RelationStep(m) if kind == Vocabulary.DataStep_CLASS: - return DataStep(m) + return impl.DataStep(m) if kind == Vocabulary.MeltStep_CLASS: - return MeltStep(m) + return impl.MeltStep(m) if kind == Vocabulary.JoinStep_CLASS: - return JoinStep(m) + return impl.JoinStep(m) if kind == Vocabulary.WizardStep_CLASS: - return WizardStep(m) + return impl.WizardStep(m) if kind == Vocabulary.CrossTabStep_CLASS: - return CrossTabStep(m) + return impl.CrossTabStep(m) if kind == Vocabulary.GroupStep_CLASS: - return GroupStep(m) + return impl.GroupStep(m) if kind == Vocabulary.InStep_CLASS: - return InStep(m) + return impl.InStep(m) if kind == Vocabulary.OutStep_CLASS: - return OutStep(m) + return impl.OutStep(m) if kind == Vocabulary.TableStep_CLASS: - return TableStep(m) + return impl.TableStep(m) if kind == Vocabulary.NamespaceStep_CLASS: - return NamespaceStep(m) + return impl.NamespaceStep(m) raise ValueError("bad kind : " + kind + " for class RelationStep in createFromJson") @@ -2654,26 +2521,21 @@ def toJson(self): return m -class RelationStep(RelationStepBase): - def __init__(self, m=None): - super().__init__(m) - - -class GroupStepBase(RelationStep): +class GroupStepBase: def __init__(self, m=None): import tercen.model.impl as impl - if ("RelationStep", impl.RelationStep) in inspect.getmembers(impl): - GroupStepBase.__bases__ = (impl.RelationStep,) + GroupStepBase.__bases__ = (impl.RelationStep,) if m is None: super().__init__(m) self.appId = "" self.appName = "" self.version = "" - self.offset = Point() + self.offset = impl.Point() else: self.fromJson(m) def fromJson(self, m): + import tercen.model.impl as impl super().fromJson(m) self.subKind = m.get(Vocabulary.SUBKIND) if self.subKind is None and m.get(Vocabulary.KIND) != Vocabulary.GroupStep_CLASS: @@ -2682,15 +2544,16 @@ def fromJson(self, m): self.appName = m[Vocabulary.appName_DP] self.version = m[Vocabulary.version_DP] if m.get(Vocabulary.offset_OP) is None: - self.offset = Point() + self.offset = impl.Point() else: self.offset = PointBase.createFromJson(m.get(Vocabulary.offset_OP)) @classmethod def createFromJson(cls, m): + import tercen.model.impl as impl kind = m.get(Vocabulary.KIND) if kind == Vocabulary.GroupStep_CLASS: - return GroupStep(m) + return impl.GroupStep(m) raise ValueError("bad kind : " + kind + " for class GroupStep in createFromJson") @@ -2708,16 +2571,10 @@ def toJson(self): return m -class GroupStep(GroupStepBase): - def __init__(self, m=None): - super().__init__(m) - - -class TaskEventBase(Event): +class TaskEventBase: def __init__(self, m=None): import tercen.model.impl as impl - if ("Event", impl.Event) in inspect.getmembers(impl): - TaskEventBase.__bases__ = (impl.Event,) + TaskEventBase.__bases__ = (impl.Event,) if m is None: super().__init__(m) self.taskId = "" @@ -2725,6 +2582,7 @@ def __init__(self, m=None): self.fromJson(m) def fromJson(self, m): + import tercen.model.impl as impl super().fromJson(m) self.subKind = m.get(Vocabulary.SUBKIND) if self.subKind is None and m.get(Vocabulary.KIND) != Vocabulary.TaskEvent_CLASS: @@ -2733,17 +2591,18 @@ def fromJson(self, m): @classmethod def createFromJson(cls, m): + import tercen.model.impl as impl kind = m.get(Vocabulary.KIND) if kind == Vocabulary.TaskEvent_CLASS: - return TaskEvent(m) + return impl.TaskEvent(m) if kind == Vocabulary.TaskLogEvent_CLASS: - return TaskLogEvent(m) + return impl.TaskLogEvent(m) if kind == Vocabulary.TaskProgressEvent_CLASS: - return TaskProgressEvent(m) + return impl.TaskProgressEvent(m) if kind == Vocabulary.TaskDataEvent_CLASS: - return TaskDataEvent(m) + return impl.TaskDataEvent(m) if kind == Vocabulary.TaskStateEvent_CLASS: - return TaskStateEvent(m) + return impl.TaskStateEvent(m) raise ValueError("bad kind : " + kind + " for class TaskEvent in createFromJson") @@ -2758,16 +2617,10 @@ def toJson(self): return m -class TaskEvent(TaskEventBase): - def __init__(self, m=None): - super().__init__(m) - - -class TaskLogEventBase(TaskEvent): +class TaskLogEventBase: def __init__(self, m=None): import tercen.model.impl as impl - if ("TaskEvent", impl.TaskEvent) in inspect.getmembers(impl): - TaskLogEventBase.__bases__ = (impl.TaskEvent,) + TaskLogEventBase.__bases__ = (impl.TaskEvent,) if m is None: super().__init__(m) self.message = "" @@ -2775,6 +2628,7 @@ def __init__(self, m=None): self.fromJson(m) def fromJson(self, m): + import tercen.model.impl as impl super().fromJson(m) self.subKind = m.get(Vocabulary.SUBKIND) if self.subKind is None and m.get(Vocabulary.KIND) != Vocabulary.TaskLogEvent_CLASS: @@ -2783,9 +2637,10 @@ def fromJson(self, m): @classmethod def createFromJson(cls, m): + import tercen.model.impl as impl kind = m.get(Vocabulary.KIND) if kind == Vocabulary.TaskLogEvent_CLASS: - return TaskLogEvent(m) + return impl.TaskLogEvent(m) raise ValueError("bad kind : " + kind + " for class TaskLogEvent in createFromJson") @@ -2800,48 +2655,44 @@ def toJson(self): return m -class TaskLogEvent(TaskLogEventBase): - def __init__(self, m=None): - super().__init__(m) - - -class UserSessionBase(SciObject): +class UserSessionBase: def __init__(self, m=None): import tercen.model.impl as impl - if ("SciObject", impl.SciObject) in inspect.getmembers(impl): - UserSessionBase.__bases__ = (impl.SciObject,) + UserSessionBase.__bases__ = (impl.SciObject,) if m is None: super().__init__(m) - self.serverVersion = Version() - self.user = User() - self.token = Token() + self.serverVersion = impl.Version() + self.user = impl.User() + self.token = impl.Token() else: self.fromJson(m) def fromJson(self, m): + import tercen.model.impl as impl super().fromJson(m) self.subKind = m.get(Vocabulary.SUBKIND) if self.subKind is None and m.get(Vocabulary.KIND) != Vocabulary.UserSession_CLASS: self.subKind = m.get(Vocabulary.KIND) if m.get(Vocabulary.serverVersion_OP) is None: - self.serverVersion = Version() + self.serverVersion = impl.Version() else: self.serverVersion = VersionBase.createFromJson( m.get(Vocabulary.serverVersion_OP)) if m.get(Vocabulary.user_OP) is None: - self.user = User() + self.user = impl.User() else: self.user = UserBase.createFromJson(m.get(Vocabulary.user_OP)) if m.get(Vocabulary.token_OP) is None: - self.token = Token() + self.token = impl.Token() else: self.token = TokenBase.createFromJson(m.get(Vocabulary.token_OP)) @classmethod def createFromJson(cls, m): + import tercen.model.impl as impl kind = m.get(Vocabulary.KIND) if kind == Vocabulary.UserSession_CLASS: - return UserSession(m) + return impl.UserSession(m) raise ValueError("bad kind : " + kind + " for class UserSession in createFromJson") @@ -2858,32 +2709,27 @@ def toJson(self): return m -class UserSession(UserSessionBase): - def __init__(self, m=None): - super().__init__(m) - - -class TableBase(SciObject): +class TableBase: def __init__(self, m=None): import tercen.model.impl as impl - if ("SciObject", impl.SciObject) in inspect.getmembers(impl): - TableBase.__bases__ = (impl.SciObject,) + TableBase.__bases__ = (impl.SciObject,) if m is None: super().__init__(m) self.nRows = 0 - self.properties = TableProperties() + self.properties = impl.TableProperties() self.columns = list() else: self.fromJson(m) def fromJson(self, m): + import tercen.model.impl as impl super().fromJson(m) self.subKind = m.get(Vocabulary.SUBKIND) if self.subKind is None and m.get(Vocabulary.KIND) != Vocabulary.Table_CLASS: self.subKind = m.get(Vocabulary.KIND) self.nRows = m[Vocabulary.nRows_DP] if m.get(Vocabulary.properties_OP) is None: - self.properties = TableProperties() + self.properties = impl.TableProperties() else: self.properties = TablePropertiesBase.createFromJson( m.get(Vocabulary.properties_OP)) @@ -2896,9 +2742,10 @@ def fromJson(self, m): @classmethod def createFromJson(cls, m): + import tercen.model.impl as impl kind = m.get(Vocabulary.KIND) if kind == Vocabulary.Table_CLASS: - return Table(m) + return impl.Table(m) raise ValueError("bad kind : " + kind + " for class Table in createFromJson") @@ -2916,16 +2763,10 @@ def toJson(self): return m -class Table(TableBase): - def __init__(self, m=None): - super().__init__(m) - - -class OperatorBase(Document): +class OperatorBase: def __init__(self, m=None): import tercen.model.impl as impl - if ("Document", impl.Document) in inspect.getmembers(impl): - OperatorBase.__bases__ = (impl.Document,) + OperatorBase.__bases__ = (impl.Document,) if m is None: super().__init__(m) self.longDescription = "" @@ -2934,6 +2775,7 @@ def __init__(self, m=None): self.fromJson(m) def fromJson(self, m): + import tercen.model.impl as impl super().fromJson(m) self.subKind = m.get(Vocabulary.SUBKIND) if self.subKind is None and m.get(Vocabulary.KIND) != Vocabulary.Operator_CLASS: @@ -2948,21 +2790,22 @@ def fromJson(self, m): @classmethod def createFromJson(cls, m): + import tercen.model.impl as impl kind = m.get(Vocabulary.KIND) if kind == Vocabulary.Operator_CLASS: - return Operator(m) + return impl.Operator(m) if kind == Vocabulary.ShinyOperator_CLASS: - return ShinyOperator(m) + return impl.ShinyOperator(m) if kind == Vocabulary.DockerWebAppOperator_CLASS: - return DockerWebAppOperator(m) + return impl.DockerWebAppOperator(m) if kind == Vocabulary.DockerOperator_CLASS: - return DockerOperator(m) + return impl.DockerOperator(m) if kind == Vocabulary.ROperator_CLASS: - return ROperator(m) + return impl.ROperator(m) if kind == Vocabulary.WebAppOperator_CLASS: - return WebAppOperator(m) + return impl.WebAppOperator(m) if kind == Vocabulary.GitOperator_CLASS: - return GitOperator(m) + return impl.GitOperator(m) raise ValueError("bad kind : " + kind + " for class Operator in createFromJson") @@ -2979,16 +2822,10 @@ def toJson(self): return m -class Operator(OperatorBase): - def __init__(self, m=None): - super().__init__(m) - - -class GitOperatorBase(Operator): +class GitOperatorBase: def __init__(self, m=None): import tercen.model.impl as impl - if ("Operator", impl.Operator) in inspect.getmembers(impl): - GitOperatorBase.__bases__ = (impl.Operator,) + GitOperatorBase.__bases__ = (impl.Operator,) if m is None: super().__init__(m) self.path = "" @@ -2996,6 +2833,7 @@ def __init__(self, m=None): self.fromJson(m) def fromJson(self, m): + import tercen.model.impl as impl super().fromJson(m) self.subKind = m.get(Vocabulary.SUBKIND) if self.subKind is None and m.get(Vocabulary.KIND) != Vocabulary.GitOperator_CLASS: @@ -3004,19 +2842,20 @@ def fromJson(self, m): @classmethod def createFromJson(cls, m): + import tercen.model.impl as impl kind = m.get(Vocabulary.KIND) if kind == Vocabulary.GitOperator_CLASS: - return GitOperator(m) + return impl.GitOperator(m) if kind == Vocabulary.ShinyOperator_CLASS: - return ShinyOperator(m) + return impl.ShinyOperator(m) if kind == Vocabulary.DockerWebAppOperator_CLASS: - return DockerWebAppOperator(m) + return impl.DockerWebAppOperator(m) if kind == Vocabulary.DockerOperator_CLASS: - return DockerOperator(m) + return impl.DockerOperator(m) if kind == Vocabulary.ROperator_CLASS: - return ROperator(m) + return impl.ROperator(m) if kind == Vocabulary.WebAppOperator_CLASS: - return WebAppOperator(m) + return impl.WebAppOperator(m) raise ValueError("bad kind : " + kind + " for class GitOperator in createFromJson") @@ -3031,16 +2870,10 @@ def toJson(self): return m -class GitOperator(GitOperatorBase): - def __init__(self, m=None): - super().__init__(m) - - -class DockerOperatorBase(GitOperator): +class DockerOperatorBase: def __init__(self, m=None): import tercen.model.impl as impl - if ("GitOperator", impl.GitOperator) in inspect.getmembers(impl): - DockerOperatorBase.__bases__ = (impl.GitOperator,) + DockerOperatorBase.__bases__ = (impl.GitOperator,) if m is None: super().__init__(m) self.container = "" @@ -3048,6 +2881,7 @@ def __init__(self, m=None): self.fromJson(m) def fromJson(self, m): + import tercen.model.impl as impl super().fromJson(m) self.subKind = m.get(Vocabulary.SUBKIND) if self.subKind is None and m.get(Vocabulary.KIND) != Vocabulary.DockerOperator_CLASS: @@ -3056,9 +2890,10 @@ def fromJson(self, m): @classmethod def createFromJson(cls, m): + import tercen.model.impl as impl kind = m.get(Vocabulary.KIND) if kind == Vocabulary.DockerOperator_CLASS: - return DockerOperator(m) + return impl.DockerOperator(m) raise ValueError("bad kind : " + kind + " for class DockerOperator in createFromJson") @@ -3073,16 +2908,10 @@ def toJson(self): return m -class DockerOperator(DockerOperatorBase): - def __init__(self, m=None): - super().__init__(m) - - -class AclBase(SciObject): +class AclBase: def __init__(self, m=None): import tercen.model.impl as impl - if ("SciObject", impl.SciObject) in inspect.getmembers(impl): - AclBase.__bases__ = (impl.SciObject,) + AclBase.__bases__ = (impl.SciObject,) if m is None: super().__init__(m) self.owner = "" @@ -3091,6 +2920,7 @@ def __init__(self, m=None): self.fromJson(m) def fromJson(self, m): + import tercen.model.impl as impl super().fromJson(m) self.subKind = m.get(Vocabulary.SUBKIND) if self.subKind is None and m.get(Vocabulary.KIND) != Vocabulary.Acl_CLASS: @@ -3105,9 +2935,10 @@ def fromJson(self, m): @classmethod def createFromJson(cls, m): + import tercen.model.impl as impl kind = m.get(Vocabulary.KIND) if kind == Vocabulary.Acl_CLASS: - return Acl(m) + return impl.Acl(m) raise ValueError("bad kind : " + kind + " for class Acl in createFromJson") @@ -3123,21 +2954,17 @@ def toJson(self): return m -class Acl(AclBase): - def __init__(self, m=None): - super().__init__(m) - - -class CubeAxisQueryBase(BaseObject): +class CubeAxisQueryBase: def __init__(self, m=None): + import tercen.model.impl as impl if m is None: super().__init__(m) self.pointSize = 0 self.chartType = "" - self.yAxis = Factor() - self.yAxisSettings = AxisSettings() - self.xAxis = Factor() - self.xAxisSettings = AxisSettings() + self.yAxis = impl.Factor() + self.yAxisSettings = impl.AxisSettings() + self.xAxis = impl.Factor() + self.xAxisSettings = impl.AxisSettings() self.errors = list() self.labels = list() self.colors = list() @@ -3146,6 +2973,7 @@ def __init__(self, m=None): self.fromJson(m) def fromJson(self, m): + import tercen.model.impl as impl super().fromJson(m) self.subKind = m.get(Vocabulary.SUBKIND) if self.subKind is None and m.get(Vocabulary.KIND) != Vocabulary.CubeAxisQuery_CLASS: @@ -3153,20 +2981,20 @@ def fromJson(self, m): self.pointSize = m[Vocabulary.pointSize_DP] self.chartType = m[Vocabulary.chartType_DP] if m.get(Vocabulary.yAxis_OP) is None: - self.yAxis = Factor() + self.yAxis = impl.Factor() else: self.yAxis = FactorBase.createFromJson(m.get(Vocabulary.yAxis_OP)) if m.get(Vocabulary.yAxisSettings_OP) is None: - self.yAxisSettings = AxisSettings() + self.yAxisSettings = impl.AxisSettings() else: self.yAxisSettings = AxisSettingsBase.createFromJson( m.get(Vocabulary.yAxisSettings_OP)) if m.get(Vocabulary.xAxis_OP) is None: - self.xAxis = Factor() + self.xAxis = impl.Factor() else: self.xAxis = FactorBase.createFromJson(m.get(Vocabulary.xAxis_OP)) if m.get(Vocabulary.xAxisSettings_OP) is None: - self.xAxisSettings = AxisSettings() + self.xAxisSettings = impl.AxisSettings() else: self.xAxisSettings = AxisSettingsBase.createFromJson( m.get(Vocabulary.xAxisSettings_OP)) @@ -3197,9 +3025,10 @@ def fromJson(self, m): @classmethod def createFromJson(cls, m): + import tercen.model.impl as impl kind = m.get(Vocabulary.KIND) if kind == Vocabulary.CubeAxisQuery_CLASS: - return CubeAxisQuery(m) + return impl.CubeAxisQuery(m) raise ValueError("bad kind : " + kind + " for class CubeAxisQuery in createFromJson") @@ -3224,27 +3053,22 @@ def toJson(self): return m -class CubeAxisQuery(CubeAxisQueryBase): - def __init__(self, m=None): - super().__init__(m) - - -class GateNodeBase(SciObject): +class GateNodeBase: def __init__(self, m=None): import tercen.model.impl as impl - if ("SciObject", impl.SciObject) in inspect.getmembers(impl): - GateNodeBase.__bases__ = (impl.SciObject,) + GateNodeBase.__bases__ = (impl.SciObject,) if m is None: super().__init__(m) self.nodeId = "" self.name = "" - self.crosstab = Crosstab() + self.crosstab = impl.Crosstab() self.children = list() self.statistics = list() else: self.fromJson(m) def fromJson(self, m): + import tercen.model.impl as impl super().fromJson(m) self.subKind = m.get(Vocabulary.SUBKIND) if self.subKind is None and m.get(Vocabulary.KIND) != Vocabulary.GateNode_CLASS: @@ -3252,7 +3076,7 @@ def fromJson(self, m): self.nodeId = m[Vocabulary.nodeId_DP] self.name = m[Vocabulary.name_DP] if m.get(Vocabulary.crosstab_OP) is None: - self.crosstab = Crosstab() + self.crosstab = impl.Crosstab() else: self.crosstab = CrosstabBase.createFromJson( m.get(Vocabulary.crosstab_OP)) @@ -3271,9 +3095,10 @@ def fromJson(self, m): @classmethod def createFromJson(cls, m): + import tercen.model.impl as impl kind = m.get(Vocabulary.KIND) if kind == Vocabulary.GateNode_CLASS: - return GateNode(m) + return impl.GateNode(m) raise ValueError("bad kind : " + kind + " for class GateNode in createFromJson") @@ -3294,16 +3119,10 @@ def toJson(self): return m -class GateNode(GateNodeBase): - def __init__(self, m=None): - super().__init__(m) - - -class TaskSummaryBase(SciObject): +class TaskSummaryBase: def __init__(self, m=None): import tercen.model.impl as impl - if ("SciObject", impl.SciObject) in inspect.getmembers(impl): - TaskSummaryBase.__bases__ = (impl.SciObject,) + TaskSummaryBase.__bases__ = (impl.SciObject,) if m is None: super().__init__(m) self.n = 0 @@ -3312,6 +3131,7 @@ def __init__(self, m=None): self.fromJson(m) def fromJson(self, m): + import tercen.model.impl as impl super().fromJson(m) self.subKind = m.get(Vocabulary.SUBKIND) if self.subKind is None and m.get(Vocabulary.KIND) != Vocabulary.TaskSummary_CLASS: @@ -3321,9 +3141,10 @@ def fromJson(self, m): @classmethod def createFromJson(cls, m): + import tercen.model.impl as impl kind = m.get(Vocabulary.KIND) if kind == Vocabulary.TaskSummary_CLASS: - return TaskSummary(m) + return impl.TaskSummary(m) raise ValueError("bad kind : " + kind + " for class TaskSummary in createFromJson") @@ -3339,16 +3160,10 @@ def toJson(self): return m -class TaskSummary(TaskSummaryBase): - def __init__(self, m=None): - super().__init__(m) - - -class PaletteBase(SciObject): +class PaletteBase: def __init__(self, m=None): import tercen.model.impl as impl - if ("SciObject", impl.SciObject) in inspect.getmembers(impl): - PaletteBase.__bases__ = (impl.SciObject,) + PaletteBase.__bases__ = (impl.SciObject,) if m is None: super().__init__(m) self.backcolor = 0 @@ -3357,6 +3172,7 @@ def __init__(self, m=None): self.fromJson(m) def fromJson(self, m): + import tercen.model.impl as impl super().fromJson(m) self.subKind = m.get(Vocabulary.SUBKIND) if self.subKind is None and m.get(Vocabulary.KIND) != Vocabulary.Palette_CLASS: @@ -3371,15 +3187,16 @@ def fromJson(self, m): @classmethod def createFromJson(cls, m): + import tercen.model.impl as impl kind = m.get(Vocabulary.KIND) if kind == Vocabulary.Palette_CLASS: - return Palette(m) + return impl.Palette(m) if kind == Vocabulary.JetPalette_CLASS: - return JetPalette(m) + return impl.JetPalette(m) if kind == Vocabulary.RampPalette_CLASS: - return RampPalette(m) + return impl.RampPalette(m) if kind == Vocabulary.CategoryPalette_CLASS: - return CategoryPalette(m) + return impl.CategoryPalette(m) raise ValueError("bad kind : " + kind + " for class Palette in createFromJson") @@ -3396,16 +3213,10 @@ def toJson(self): return m -class Palette(PaletteBase): - def __init__(self, m=None): - super().__init__(m) - - -class RampPaletteBase(Palette): +class RampPaletteBase: def __init__(self, m=None): import tercen.model.impl as impl - if ("Palette", impl.Palette) in inspect.getmembers(impl): - RampPaletteBase.__bases__ = (impl.Palette,) + RampPaletteBase.__bases__ = (impl.Palette,) if m is None: super().__init__(m) self.isUserDefined = True @@ -3414,6 +3225,7 @@ def __init__(self, m=None): self.fromJson(m) def fromJson(self, m): + import tercen.model.impl as impl super().fromJson(m) self.subKind = m.get(Vocabulary.SUBKIND) if self.subKind is None and m.get(Vocabulary.KIND) != Vocabulary.RampPalette_CLASS: @@ -3429,11 +3241,12 @@ def fromJson(self, m): @classmethod def createFromJson(cls, m): + import tercen.model.impl as impl kind = m.get(Vocabulary.KIND) if kind == Vocabulary.RampPalette_CLASS: - return RampPalette(m) + return impl.RampPalette(m) if kind == Vocabulary.JetPalette_CLASS: - return JetPalette(m) + return impl.JetPalette(m) raise ValueError("bad kind : " + kind + " for class RampPalette in createFromJson") @@ -3450,24 +3263,19 @@ def toJson(self): return m -class RampPalette(RampPaletteBase): - def __init__(self, m=None): - super().__init__(m) - - -class DistinctRelationBase(Relation): +class DistinctRelationBase: def __init__(self, m=None): import tercen.model.impl as impl - if ("Relation", impl.Relation) in inspect.getmembers(impl): - DistinctRelationBase.__bases__ = (impl.Relation,) + DistinctRelationBase.__bases__ = (impl.Relation,) if m is None: super().__init__(m) self.group = list() - self.relation = Relation() + self.relation = impl.Relation() else: self.fromJson(m) def fromJson(self, m): + import tercen.model.impl as impl super().fromJson(m) self.subKind = m.get(Vocabulary.SUBKIND) if self.subKind is None and m.get(Vocabulary.KIND) != Vocabulary.DistinctRelation_CLASS: @@ -3477,16 +3285,17 @@ def fromJson(self, m): else: self.group = m[Vocabulary.group_DP] if m.get(Vocabulary.relation_OP) is None: - self.relation = Relation() + self.relation = impl.Relation() else: self.relation = RelationBase.createFromJson( m.get(Vocabulary.relation_OP)) @classmethod def createFromJson(cls, m): + import tercen.model.impl as impl kind = m.get(Vocabulary.KIND) if kind == Vocabulary.DistinctRelation_CLASS: - return DistinctRelation(m) + return impl.DistinctRelation(m) raise ValueError("bad kind : " + kind + " for class DistinctRelation in createFromJson") @@ -3502,16 +3311,10 @@ def toJson(self): return m -class DistinctRelation(DistinctRelationBase): - def __init__(self, m=None): - super().__init__(m) - - -class RunningDependentStateBase(State): +class RunningDependentStateBase: def __init__(self, m=None): import tercen.model.impl as impl - if ("State", impl.State) in inspect.getmembers(impl): - RunningDependentStateBase.__bases__ = (impl.State,) + RunningDependentStateBase.__bases__ = (impl.State,) if m is not None: self.fromJson(m) @@ -3519,6 +3322,7 @@ def __init__(self, m=None): super().__init__(m) def fromJson(self, m): + import tercen.model.impl as impl super().fromJson(m) self.subKind = m.get(Vocabulary.SUBKIND) if self.subKind is None and m.get(Vocabulary.KIND) != Vocabulary.RunningDependentState_CLASS: @@ -3526,9 +3330,10 @@ def fromJson(self, m): @classmethod def createFromJson(cls, m): + import tercen.model.impl as impl kind = m.get(Vocabulary.KIND) if kind == Vocabulary.RunningDependentState_CLASS: - return RunningDependentState(m) + return impl.RunningDependentState(m) raise ValueError("bad kind : " + kind + " for class RunningDependentState in createFromJson") @@ -3542,16 +3347,10 @@ def toJson(self): return m -class RunningDependentState(RunningDependentStateBase): - def __init__(self, m=None): - super().__init__(m) - - -class TaskBase(PersistentObject): +class TaskBase: def __init__(self, m=None): import tercen.model.impl as impl - if ("PersistentObject", impl.PersistentObject) in inspect.getmembers(impl): - TaskBase.__bases__ = (impl.PersistentObject,) + TaskBase.__bases__ = (impl.PersistentObject,) if m is None: super().__init__(m) self.duration = 0.0 @@ -3559,17 +3358,18 @@ def __init__(self, m=None): self.taskHash = "" self.channelId = "" self.environment = list() - self.state = State() - self.createdDate = Date() - self.lastModifiedDate = Date() - self.runDate = Date() - self.completedDate = Date() - self.aclContext = AclContext() + self.state = impl.State() + self.createdDate = impl.Date() + self.lastModifiedDate = impl.Date() + self.runDate = impl.Date() + self.completedDate = impl.Date() + self.aclContext = impl.AclContext() self.meta = list() else: self.fromJson(m) def fromJson(self, m): + import tercen.model.impl as impl super().fromJson(m) self.subKind = m.get(Vocabulary.SUBKIND) if self.subKind is None and m.get(Vocabulary.KIND) != Vocabulary.Task_CLASS: @@ -3585,31 +3385,31 @@ def fromJson(self, m): for o in m.get(Vocabulary.environment_OP): self.environment.append(PairBase.createFromJson(o)) if m.get(Vocabulary.state_OP) is None: - self.state = State() + self.state = impl.State() else: self.state = StateBase.createFromJson(m.get(Vocabulary.state_OP)) if m.get(Vocabulary.createdDate_OP) is None: - self.createdDate = Date() + self.createdDate = impl.Date() else: self.createdDate = DateBase.createFromJson( m.get(Vocabulary.createdDate_OP)) if m.get(Vocabulary.lastModifiedDate_OP) is None: - self.lastModifiedDate = Date() + self.lastModifiedDate = impl.Date() else: self.lastModifiedDate = DateBase.createFromJson( m.get(Vocabulary.lastModifiedDate_OP)) if m.get(Vocabulary.runDate_OP) is None: - self.runDate = Date() + self.runDate = impl.Date() else: self.runDate = DateBase.createFromJson( m.get(Vocabulary.runDate_OP)) if m.get(Vocabulary.completedDate_OP) is None: - self.completedDate = Date() + self.completedDate = impl.Date() else: self.completedDate = DateBase.createFromJson( m.get(Vocabulary.completedDate_OP)) if m.get(Vocabulary.aclContext_OP) is None: - self.aclContext = AclContext() + self.aclContext = impl.AclContext() else: self.aclContext = AclContextBase.createFromJson( m.get(Vocabulary.aclContext_OP)) @@ -3622,45 +3422,46 @@ def fromJson(self, m): @classmethod def createFromJson(cls, m): + import tercen.model.impl as impl kind = m.get(Vocabulary.KIND) if kind == Vocabulary.Task_CLASS: - return Task(m) + return impl.Task(m) if kind == Vocabulary.RunComputationTask_CLASS: - return RunComputationTask(m) + return impl.RunComputationTask(m) if kind == Vocabulary.SaveComputationResultTask_CLASS: - return SaveComputationResultTask(m) + return impl.SaveComputationResultTask(m) if kind == Vocabulary.ComputationTask_CLASS: - return ComputationTask(m) + return impl.ComputationTask(m) if kind == Vocabulary.ImportGitWorkflowTask_CLASS: - return ImportGitWorkflowTask(m) + return impl.ImportGitWorkflowTask(m) if kind == Vocabulary.ExportWorkflowTask_CLASS: - return ExportWorkflowTask(m) + return impl.ExportWorkflowTask(m) if kind == Vocabulary.CSVTask_CLASS: - return CSVTask(m) + return impl.CSVTask(m) if kind == Vocabulary.CubeQueryTask_CLASS: - return CubeQueryTask(m) + return impl.CubeQueryTask(m) if kind == Vocabulary.ImportWorkflowTask_CLASS: - return ImportWorkflowTask(m) + return impl.ImportWorkflowTask(m) if kind == Vocabulary.TestOperatorTask_CLASS: - return TestOperatorTask(m) + return impl.TestOperatorTask(m) if kind == Vocabulary.ImportGitDatasetTask_CLASS: - return ImportGitDatasetTask(m) + return impl.ImportGitDatasetTask(m) if kind == Vocabulary.RunWorkflowTask_CLASS: - return RunWorkflowTask(m) + return impl.RunWorkflowTask(m) if kind == Vocabulary.RunWebAppTask_CLASS: - return RunWebAppTask(m) + return impl.RunWebAppTask(m) if kind == Vocabulary.ExportTableTask_CLASS: - return ExportTableTask(m) + return impl.ExportTableTask(m) if kind == Vocabulary.ProjectTask_CLASS: - return ProjectTask(m) + return impl.ProjectTask(m) if kind == Vocabulary.GlTask_CLASS: - return GlTask(m) + return impl.GlTask(m) if kind == Vocabulary.LibraryTask_CLASS: - return LibraryTask(m) + return impl.LibraryTask(m) if kind == Vocabulary.CreateGitOperatorTask_CLASS: - return CreateGitOperatorTask(m) + return impl.CreateGitOperatorTask(m) if kind == Vocabulary.GitProjectTask_CLASS: - return GitProjectTask(m) + return impl.GitProjectTask(m) raise ValueError("bad kind : " + kind + " for class Task in createFromJson") @@ -3687,16 +3488,10 @@ def toJson(self): return m -class Task(TaskBase): - def __init__(self, m=None): - super().__init__(m) - - -class ProjectTaskBase(Task): +class ProjectTaskBase: def __init__(self, m=None): import tercen.model.impl as impl - if ("Task", impl.Task) in inspect.getmembers(impl): - ProjectTaskBase.__bases__ = (impl.Task,) + ProjectTaskBase.__bases__ = (impl.Task,) if m is None: super().__init__(m) self.projectId = "" @@ -3704,6 +3499,7 @@ def __init__(self, m=None): self.fromJson(m) def fromJson(self, m): + import tercen.model.impl as impl super().fromJson(m) self.subKind = m.get(Vocabulary.SUBKIND) if self.subKind is None and m.get(Vocabulary.KIND) != Vocabulary.ProjectTask_CLASS: @@ -3712,35 +3508,36 @@ def fromJson(self, m): @classmethod def createFromJson(cls, m): + import tercen.model.impl as impl kind = m.get(Vocabulary.KIND) if kind == Vocabulary.ProjectTask_CLASS: - return ProjectTask(m) + return impl.ProjectTask(m) if kind == Vocabulary.RunComputationTask_CLASS: - return RunComputationTask(m) + return impl.RunComputationTask(m) if kind == Vocabulary.SaveComputationResultTask_CLASS: - return SaveComputationResultTask(m) + return impl.SaveComputationResultTask(m) if kind == Vocabulary.ComputationTask_CLASS: - return ComputationTask(m) + return impl.ComputationTask(m) if kind == Vocabulary.ImportGitWorkflowTask_CLASS: - return ImportGitWorkflowTask(m) + return impl.ImportGitWorkflowTask(m) if kind == Vocabulary.ExportWorkflowTask_CLASS: - return ExportWorkflowTask(m) + return impl.ExportWorkflowTask(m) if kind == Vocabulary.CSVTask_CLASS: - return CSVTask(m) + return impl.CSVTask(m) if kind == Vocabulary.CubeQueryTask_CLASS: - return CubeQueryTask(m) + return impl.CubeQueryTask(m) if kind == Vocabulary.ImportWorkflowTask_CLASS: - return ImportWorkflowTask(m) + return impl.ImportWorkflowTask(m) if kind == Vocabulary.TestOperatorTask_CLASS: - return TestOperatorTask(m) + return impl.TestOperatorTask(m) if kind == Vocabulary.ImportGitDatasetTask_CLASS: - return ImportGitDatasetTask(m) + return impl.ImportGitDatasetTask(m) if kind == Vocabulary.RunWorkflowTask_CLASS: - return RunWorkflowTask(m) + return impl.RunWorkflowTask(m) if kind == Vocabulary.RunWebAppTask_CLASS: - return RunWebAppTask(m) + return impl.RunWebAppTask(m) if kind == Vocabulary.ExportTableTask_CLASS: - return ExportTableTask(m) + return impl.ExportTableTask(m) raise ValueError("bad kind : " + kind + " for class ProjectTask in createFromJson") @@ -3755,16 +3552,10 @@ def toJson(self): return m -class ProjectTask(ProjectTaskBase): - def __init__(self, m=None): - super().__init__(m) - - -class ExportWorkflowTaskBase(ProjectTask): +class ExportWorkflowTaskBase: def __init__(self, m=None): import tercen.model.impl as impl - if ("ProjectTask", impl.ProjectTask) in inspect.getmembers(impl): - ExportWorkflowTaskBase.__bases__ = (impl.ProjectTask,) + ExportWorkflowTaskBase.__bases__ = (impl.ProjectTask,) if m is None: super().__init__(m) self.workflowId = "" @@ -3773,6 +3564,7 @@ def __init__(self, m=None): self.fromJson(m) def fromJson(self, m): + import tercen.model.impl as impl super().fromJson(m) self.subKind = m.get(Vocabulary.SUBKIND) if self.subKind is None and m.get(Vocabulary.KIND) != Vocabulary.ExportWorkflowTask_CLASS: @@ -3782,9 +3574,10 @@ def fromJson(self, m): @classmethod def createFromJson(cls, m): + import tercen.model.impl as impl kind = m.get(Vocabulary.KIND) if kind == Vocabulary.ExportWorkflowTask_CLASS: - return ExportWorkflowTask(m) + return impl.ExportWorkflowTask(m) raise ValueError("bad kind : " + kind + " for class ExportWorkflowTask in createFromJson") @@ -3800,16 +3593,10 @@ def toJson(self): return m -class ExportWorkflowTask(ExportWorkflowTaskBase): - def __init__(self, m=None): - super().__init__(m) - - -class StartProcessBase(IdObject): +class StartProcessBase: def __init__(self, m=None): import tercen.model.impl as impl - if ("IdObject", impl.IdObject) in inspect.getmembers(impl): - StartProcessBase.__bases__ = (impl.IdObject,) + StartProcessBase.__bases__ = (impl.IdObject,) if m is None: super().__init__(m) self.executable = "" @@ -3817,11 +3604,12 @@ def __init__(self, m=None): self.timeout = 0 self.pid = 0 self.script = "" - self.ulimits = Ulimits() + self.ulimits = impl.Ulimits() else: self.fromJson(m) def fromJson(self, m): + import tercen.model.impl as impl super().fromJson(m) self.subKind = m.get(Vocabulary.SUBKIND) if self.subKind is None and m.get(Vocabulary.KIND) != Vocabulary.StartProcess_CLASS: @@ -3835,16 +3623,17 @@ def fromJson(self, m): self.pid = m[Vocabulary.pid_DP] self.script = m[Vocabulary.script_DP] if m.get(Vocabulary.ulimits_OP) is None: - self.ulimits = Ulimits() + self.ulimits = impl.Ulimits() else: self.ulimits = UlimitsBase.createFromJson( m.get(Vocabulary.ulimits_OP)) @classmethod def createFromJson(cls, m): + import tercen.model.impl as impl kind = m.get(Vocabulary.KIND) if kind == Vocabulary.StartProcess_CLASS: - return StartProcess(m) + return impl.StartProcess(m) raise ValueError("bad kind : " + kind + " for class StartProcess in createFromJson") @@ -3864,26 +3653,21 @@ def toJson(self): return m -class StartProcess(StartProcessBase): - def __init__(self, m=None): - super().__init__(m) - - -class TokenBase(SciObject): +class TokenBase: def __init__(self, m=None): import tercen.model.impl as impl - if ("SciObject", impl.SciObject) in inspect.getmembers(impl): - TokenBase.__bases__ = (impl.SciObject,) + TokenBase.__bases__ = (impl.SciObject,) if m is None: super().__init__(m) self.userId = "" self.token = "" self.domain = "" - self.expiry = Date() + self.expiry = impl.Date() else: self.fromJson(m) def fromJson(self, m): + import tercen.model.impl as impl super().fromJson(m) self.subKind = m.get(Vocabulary.SUBKIND) if self.subKind is None and m.get(Vocabulary.KIND) != Vocabulary.Token_CLASS: @@ -3892,15 +3676,16 @@ def fromJson(self, m): self.token = m[Vocabulary.token_DP] self.domain = m[Vocabulary.domain_DP] if m.get(Vocabulary.expiry_OP) is None: - self.expiry = Date() + self.expiry = impl.Date() else: self.expiry = DateBase.createFromJson(m.get(Vocabulary.expiry_OP)) @classmethod def createFromJson(cls, m): + import tercen.model.impl as impl kind = m.get(Vocabulary.KIND) if kind == Vocabulary.Token_CLASS: - return Token(m) + return impl.Token(m) raise ValueError("bad kind : " + kind + " for class Token in createFromJson") @@ -3918,13 +3703,9 @@ def toJson(self): return m -class Token(TokenBase): - def __init__(self, m=None): - super().__init__(m) - - -class ActivityCountBase(BaseObject): +class ActivityCountBase: def __init__(self, m=None): + import tercen.model.impl as impl if m is None: super().__init__(m) self.objectId = "" @@ -3933,6 +3714,7 @@ def __init__(self, m=None): self.fromJson(m) def fromJson(self, m): + import tercen.model.impl as impl super().fromJson(m) self.subKind = m.get(Vocabulary.SUBKIND) if self.subKind is None and m.get(Vocabulary.KIND) != Vocabulary.ActivityCount_CLASS: @@ -3942,9 +3724,10 @@ def fromJson(self, m): @classmethod def createFromJson(cls, m): + import tercen.model.impl as impl kind = m.get(Vocabulary.KIND) if kind == Vocabulary.ActivityCount_CLASS: - return ActivityCount(m) + return impl.ActivityCount(m) raise ValueError("bad kind : " + kind + " for class ActivityCount in createFromJson") @@ -3960,46 +3743,42 @@ def toJson(self): return m -class ActivityCount(ActivityCountBase): - def __init__(self, m=None): - super().__init__(m) - - -class JoinOperatorBase(SciObject): +class JoinOperatorBase: def __init__(self, m=None): import tercen.model.impl as impl - if ("SciObject", impl.SciObject) in inspect.getmembers(impl): - JoinOperatorBase.__bases__ = (impl.SciObject,) + JoinOperatorBase.__bases__ = (impl.SciObject,) if m is None: super().__init__(m) self.joinType = "" - self.leftPair = ColumnPair() - self.rightRelation = Relation() + self.leftPair = impl.ColumnPair() + self.rightRelation = impl.Relation() else: self.fromJson(m) def fromJson(self, m): + import tercen.model.impl as impl super().fromJson(m) self.subKind = m.get(Vocabulary.SUBKIND) if self.subKind is None and m.get(Vocabulary.KIND) != Vocabulary.JoinOperator_CLASS: self.subKind = m.get(Vocabulary.KIND) self.joinType = m[Vocabulary.joinType_DP] if m.get(Vocabulary.leftPair_OP) is None: - self.leftPair = ColumnPair() + self.leftPair = impl.ColumnPair() else: self.leftPair = ColumnPairBase.createFromJson( m.get(Vocabulary.leftPair_OP)) if m.get(Vocabulary.rightRelation_OP) is None: - self.rightRelation = Relation() + self.rightRelation = impl.Relation() else: self.rightRelation = RelationBase.createFromJson( m.get(Vocabulary.rightRelation_OP)) @classmethod def createFromJson(cls, m): + import tercen.model.impl as impl kind = m.get(Vocabulary.KIND) if kind == Vocabulary.JoinOperator_CLASS: - return JoinOperator(m) + return impl.JoinOperator(m) raise ValueError("bad kind : " + kind + " for class JoinOperator in createFromJson") @@ -4016,16 +3795,10 @@ def toJson(self): return m -class JoinOperator(JoinOperatorBase): - def __init__(self, m=None): - super().__init__(m) - - -class OperatorModelBase(SciObject): +class OperatorModelBase: def __init__(self, m=None): import tercen.model.impl as impl - if ("SciObject", impl.SciObject) in inspect.getmembers(impl): - OperatorModelBase.__bases__ = (impl.SciObject,) + OperatorModelBase.__bases__ = (impl.SciObject,) if m is not None: self.fromJson(m) @@ -4033,6 +3806,7 @@ def __init__(self, m=None): super().__init__(m) def fromJson(self, m): + import tercen.model.impl as impl super().fromJson(m) self.subKind = m.get(Vocabulary.SUBKIND) if self.subKind is None and m.get(Vocabulary.KIND) != Vocabulary.OperatorModel_CLASS: @@ -4040,13 +3814,14 @@ def fromJson(self, m): @classmethod def createFromJson(cls, m): + import tercen.model.impl as impl kind = m.get(Vocabulary.KIND) if kind == Vocabulary.OperatorModel_CLASS: - return OperatorModel(m) + return impl.OperatorModel(m) if kind == Vocabulary.GateOperatorModel_CLASS: - return GateOperatorModel(m) + return impl.GateOperatorModel(m) if kind == Vocabulary.AnnotationOperatorModel_CLASS: - return AnnotationOperatorModel(m) + return impl.AnnotationOperatorModel(m) raise ValueError("bad kind : " + kind + " for class OperatorModel in createFromJson") @@ -4060,16 +3835,10 @@ def toJson(self): return m -class OperatorModel(OperatorModelBase): - def __init__(self, m=None): - super().__init__(m) - - -class FileMetadataBase(SciObject): +class FileMetadataBase: def __init__(self, m=None): import tercen.model.impl as impl - if ("SciObject", impl.SciObject) in inspect.getmembers(impl): - FileMetadataBase.__bases__ = (impl.SciObject,) + FileMetadataBase.__bases__ = (impl.SciObject,) if m is None: super().__init__(m) self.contentType = "" @@ -4081,6 +3850,7 @@ def __init__(self, m=None): self.fromJson(m) def fromJson(self, m): + import tercen.model.impl as impl super().fromJson(m) self.subKind = m.get(Vocabulary.SUBKIND) if self.subKind is None and m.get(Vocabulary.KIND) != Vocabulary.FileMetadata_CLASS: @@ -4093,11 +3863,12 @@ def fromJson(self, m): @classmethod def createFromJson(cls, m): + import tercen.model.impl as impl kind = m.get(Vocabulary.KIND) if kind == Vocabulary.FileMetadata_CLASS: - return FileMetadata(m) + return impl.FileMetadata(m) if kind == Vocabulary.CSVFileMetadata_CLASS: - return CSVFileMetadata(m) + return impl.CSVFileMetadata(m) raise ValueError("bad kind : " + kind + " for class FileMetadata in createFromJson") @@ -4116,16 +3887,10 @@ def toJson(self): return m -class FileMetadata(FileMetadataBase): - def __init__(self, m=None): - super().__init__(m) - - -class CSVFileMetadataBase(FileMetadata): +class CSVFileMetadataBase: def __init__(self, m=None): import tercen.model.impl as impl - if ("FileMetadata", impl.FileMetadata) in inspect.getmembers(impl): - CSVFileMetadataBase.__bases__ = (impl.FileMetadata,) + CSVFileMetadataBase.__bases__ = (impl.FileMetadata,) if m is None: super().__init__(m) self.separator = "" @@ -4135,6 +3900,7 @@ def __init__(self, m=None): self.fromJson(m) def fromJson(self, m): + import tercen.model.impl as impl super().fromJson(m) self.subKind = m.get(Vocabulary.SUBKIND) if self.subKind is None and m.get(Vocabulary.KIND) != Vocabulary.CSVFileMetadata_CLASS: @@ -4145,9 +3911,10 @@ def fromJson(self, m): @classmethod def createFromJson(cls, m): + import tercen.model.impl as impl kind = m.get(Vocabulary.KIND) if kind == Vocabulary.CSVFileMetadata_CLASS: - return CSVFileMetadata(m) + return impl.CSVFileMetadata(m) raise ValueError("bad kind : " + kind + " for class CSVFileMetadata in createFromJson") @@ -4164,16 +3931,10 @@ def toJson(self): return m -class CSVFileMetadata(CSVFileMetadataBase): - def __init__(self, m=None): - super().__init__(m) - - -class StepModelBase(SciObject): +class StepModelBase: def __init__(self, m=None): import tercen.model.impl as impl - if ("SciObject", impl.SciObject) in inspect.getmembers(impl): - StepModelBase.__bases__ = (impl.SciObject,) + StepModelBase.__bases__ = (impl.SciObject,) if m is not None: self.fromJson(m) @@ -4181,6 +3942,7 @@ def __init__(self, m=None): super().__init__(m) def fromJson(self, m): + import tercen.model.impl as impl super().fromJson(m) self.subKind = m.get(Vocabulary.SUBKIND) if self.subKind is None and m.get(Vocabulary.KIND) != Vocabulary.StepModel_CLASS: @@ -4188,21 +3950,22 @@ def fromJson(self, m): @classmethod def createFromJson(cls, m): + import tercen.model.impl as impl kind = m.get(Vocabulary.KIND) if kind == Vocabulary.StepModel_CLASS: - return StepModel(m) + return impl.StepModel(m) if kind == Vocabulary.TableStepModel_CLASS: - return TableStepModel(m) + return impl.TableStepModel(m) if kind == Vocabulary.Crosstab_CLASS: - return Crosstab(m) + return impl.Crosstab(m) if kind == Vocabulary.JoinStepModel_CLASS: - return JoinStepModel(m) + return impl.JoinStepModel(m) if kind == Vocabulary.WizardStepModel_CLASS: - return WizardStepModel(m) + return impl.WizardStepModel(m) if kind == Vocabulary.MeltStepModel_CLASS: - return MeltStepModel(m) + return impl.MeltStepModel(m) if kind == Vocabulary.ExportModel_CLASS: - return ExportModel(m) + return impl.ExportModel(m) raise ValueError("bad kind : " + kind + " for class StepModel in createFromJson") @@ -4216,38 +3979,34 @@ def toJson(self): return m -class StepModel(StepModelBase): - def __init__(self, m=None): - super().__init__(m) - - -class TableStepModelBase(StepModel): +class TableStepModelBase: def __init__(self, m=None): import tercen.model.impl as impl - if ("StepModel", impl.StepModel) in inspect.getmembers(impl): - TableStepModelBase.__bases__ = (impl.StepModel,) + TableStepModelBase.__bases__ = (impl.StepModel,) if m is None: super().__init__(m) - self.relation = Relation() + self.relation = impl.Relation() else: self.fromJson(m) def fromJson(self, m): + import tercen.model.impl as impl super().fromJson(m) self.subKind = m.get(Vocabulary.SUBKIND) if self.subKind is None and m.get(Vocabulary.KIND) != Vocabulary.TableStepModel_CLASS: self.subKind = m.get(Vocabulary.KIND) if m.get(Vocabulary.relation_OP) is None: - self.relation = Relation() + self.relation = impl.Relation() else: self.relation = RelationBase.createFromJson( m.get(Vocabulary.relation_OP)) @classmethod def createFromJson(cls, m): + import tercen.model.impl as impl kind = m.get(Vocabulary.KIND) if kind == Vocabulary.TableStepModel_CLASS: - return TableStepModel(m) + return impl.TableStepModel(m) raise ValueError("bad kind : " + kind + " for class TableStepModel in createFromJson") @@ -4262,16 +4021,10 @@ def toJson(self): return m -class TableStepModel(TableStepModelBase): - def __init__(self, m=None): - super().__init__(m) - - -class NamespaceStepBase(RelationStep): +class NamespaceStepBase: def __init__(self, m=None): import tercen.model.impl as impl - if ("RelationStep", impl.RelationStep) in inspect.getmembers(impl): - NamespaceStepBase.__bases__ = (impl.RelationStep,) + NamespaceStepBase.__bases__ = (impl.RelationStep,) if m is not None: self.fromJson(m) @@ -4279,6 +4032,7 @@ def __init__(self, m=None): super().__init__(m) def fromJson(self, m): + import tercen.model.impl as impl super().fromJson(m) self.subKind = m.get(Vocabulary.SUBKIND) if self.subKind is None and m.get(Vocabulary.KIND) != Vocabulary.NamespaceStep_CLASS: @@ -4286,19 +4040,20 @@ def fromJson(self, m): @classmethod def createFromJson(cls, m): + import tercen.model.impl as impl kind = m.get(Vocabulary.KIND) if kind == Vocabulary.NamespaceStep_CLASS: - return NamespaceStep(m) + return impl.NamespaceStep(m) if kind == Vocabulary.DataStep_CLASS: - return DataStep(m) + return impl.DataStep(m) if kind == Vocabulary.MeltStep_CLASS: - return MeltStep(m) + return impl.MeltStep(m) if kind == Vocabulary.JoinStep_CLASS: - return JoinStep(m) + return impl.JoinStep(m) if kind == Vocabulary.WizardStep_CLASS: - return WizardStep(m) + return impl.WizardStep(m) if kind == Vocabulary.CrossTabStep_CLASS: - return CrossTabStep(m) + return impl.CrossTabStep(m) raise ValueError("bad kind : " + kind + " for class NamespaceStep in createFromJson") @@ -4312,30 +4067,25 @@ def toJson(self): return m -class NamespaceStep(NamespaceStepBase): - def __init__(self, m=None): - super().__init__(m) - - -class MeltStepBase(NamespaceStep): +class MeltStepBase: def __init__(self, m=None): import tercen.model.impl as impl - if ("NamespaceStep", impl.NamespaceStep) in inspect.getmembers(impl): - MeltStepBase.__bases__ = (impl.NamespaceStep,) + MeltStepBase.__bases__ = (impl.NamespaceStep,) if m is None: super().__init__(m) - self.model = MeltStepModel() + self.model = impl.MeltStepModel() self.meltedAttributes = list() else: self.fromJson(m) def fromJson(self, m): + import tercen.model.impl as impl super().fromJson(m) self.subKind = m.get(Vocabulary.SUBKIND) if self.subKind is None and m.get(Vocabulary.KIND) != Vocabulary.MeltStep_CLASS: self.subKind = m.get(Vocabulary.KIND) if m.get(Vocabulary.model_OP) is None: - self.model = MeltStepModel() + self.model = impl.MeltStepModel() else: self.model = MeltStepModelBase.createFromJson( m.get(Vocabulary.model_OP)) @@ -4348,9 +4098,10 @@ def fromJson(self, m): @classmethod def createFromJson(cls, m): + import tercen.model.impl as impl kind = m.get(Vocabulary.KIND) if kind == Vocabulary.MeltStep_CLASS: - return MeltStep(m) + return impl.MeltStep(m) raise ValueError("bad kind : " + kind + " for class MeltStep in createFromJson") @@ -4367,16 +4118,10 @@ def toJson(self): return m -class MeltStep(MeltStepBase): - def __init__(self, m=None): - super().__init__(m) - - -class CrosstabTableBase(SciObject): +class CrosstabTableBase: def __init__(self, m=None): import tercen.model.impl as impl - if ("SciObject", impl.SciObject) in inspect.getmembers(impl): - CrosstabTableBase.__bases__ = (impl.SciObject,) + CrosstabTableBase.__bases__ = (impl.SciObject,) if m is None: super().__init__(m) self.cellSize = 0.0 @@ -4388,6 +4133,7 @@ def __init__(self, m=None): self.fromJson(m) def fromJson(self, m): + import tercen.model.impl as impl super().fromJson(m) self.subKind = m.get(Vocabulary.SUBKIND) if self.subKind is None and m.get(Vocabulary.KIND) != Vocabulary.CrosstabTable_CLASS: @@ -4412,9 +4158,10 @@ def fromJson(self, m): @classmethod def createFromJson(cls, m): + import tercen.model.impl as impl kind = m.get(Vocabulary.KIND) if kind == Vocabulary.CrosstabTable_CLASS: - return CrosstabTable(m) + return impl.CrosstabTable(m) raise ValueError("bad kind : " + kind + " for class CrosstabTable in createFromJson") @@ -4435,16 +4182,10 @@ def toJson(self): return m -class CrosstabTable(CrosstabTableBase): - def __init__(self, m=None): - super().__init__(m) - - -class XYAxisListBase(SciObject): +class XYAxisListBase: def __init__(self, m=None): import tercen.model.impl as impl - if ("SciObject", impl.SciObject) in inspect.getmembers(impl): - XYAxisListBase.__bases__ = (impl.SciObject,) + XYAxisListBase.__bases__ = (impl.SciObject,) if m is None: super().__init__(m) self.rectangleSelections = list() @@ -4453,6 +4194,7 @@ def __init__(self, m=None): self.fromJson(m) def fromJson(self, m): + import tercen.model.impl as impl super().fromJson(m) self.subKind = m.get(Vocabulary.SUBKIND) if self.subKind is None and m.get(Vocabulary.KIND) != Vocabulary.XYAxisList_CLASS: @@ -4473,9 +4215,10 @@ def fromJson(self, m): @classmethod def createFromJson(cls, m): + import tercen.model.impl as impl kind = m.get(Vocabulary.KIND) if kind == Vocabulary.XYAxisList_CLASS: - return XYAxisList(m) + return impl.XYAxisList(m) raise ValueError("bad kind : " + kind + " for class XYAxisList in createFromJson") @@ -4492,16 +4235,10 @@ def toJson(self): return m -class XYAxisList(XYAxisListBase): - def __init__(self, m=None): - super().__init__(m) - - -class ColorElementBase(SciObject): +class ColorElementBase: def __init__(self, m=None): import tercen.model.impl as impl - if ("SciObject", impl.SciObject) in inspect.getmembers(impl): - ColorElementBase.__bases__ = (impl.SciObject,) + ColorElementBase.__bases__ = (impl.SciObject,) if m is None: super().__init__(m) self.color = 0 @@ -4509,6 +4246,7 @@ def __init__(self, m=None): self.fromJson(m) def fromJson(self, m): + import tercen.model.impl as impl super().fromJson(m) self.subKind = m.get(Vocabulary.SUBKIND) if self.subKind is None and m.get(Vocabulary.KIND) != Vocabulary.ColorElement_CLASS: @@ -4517,13 +4255,14 @@ def fromJson(self, m): @classmethod def createFromJson(cls, m): + import tercen.model.impl as impl kind = m.get(Vocabulary.KIND) if kind == Vocabulary.ColorElement_CLASS: - return ColorElement(m) + return impl.ColorElement(m) if kind == Vocabulary.DoubleColorElement_CLASS: - return DoubleColorElement(m) + return impl.DoubleColorElement(m) if kind == Vocabulary.StringColorElement_CLASS: - return StringColorElement(m) + return impl.StringColorElement(m) raise ValueError("bad kind : " + kind + " for class ColorElement in createFromJson") @@ -4538,16 +4277,10 @@ def toJson(self): return m -class ColorElement(ColorElementBase): - def __init__(self, m=None): - super().__init__(m) - - -class DoubleColorElementBase(ColorElement): +class DoubleColorElementBase: def __init__(self, m=None): import tercen.model.impl as impl - if ("ColorElement", impl.ColorElement) in inspect.getmembers(impl): - DoubleColorElementBase.__bases__ = (impl.ColorElement,) + DoubleColorElementBase.__bases__ = (impl.ColorElement,) if m is None: super().__init__(m) self.stringValue = "" @@ -4555,6 +4288,7 @@ def __init__(self, m=None): self.fromJson(m) def fromJson(self, m): + import tercen.model.impl as impl super().fromJson(m) self.subKind = m.get(Vocabulary.SUBKIND) if self.subKind is None and m.get(Vocabulary.KIND) != Vocabulary.DoubleColorElement_CLASS: @@ -4563,9 +4297,10 @@ def fromJson(self, m): @classmethod def createFromJson(cls, m): + import tercen.model.impl as impl kind = m.get(Vocabulary.KIND) if kind == Vocabulary.DoubleColorElement_CLASS: - return DoubleColorElement(m) + return impl.DoubleColorElement(m) raise ValueError("bad kind : " + kind + " for class DoubleColorElement in createFromJson") @@ -4580,16 +4315,10 @@ def toJson(self): return m -class DoubleColorElement(DoubleColorElementBase): - def __init__(self, m=None): - super().__init__(m) - - -class TaskProgressEventBase(TaskEvent): +class TaskProgressEventBase: def __init__(self, m=None): import tercen.model.impl as impl - if ("TaskEvent", impl.TaskEvent) in inspect.getmembers(impl): - TaskProgressEventBase.__bases__ = (impl.TaskEvent,) + TaskProgressEventBase.__bases__ = (impl.TaskEvent,) if m is None: super().__init__(m) self.message = "" @@ -4599,6 +4328,7 @@ def __init__(self, m=None): self.fromJson(m) def fromJson(self, m): + import tercen.model.impl as impl super().fromJson(m) self.subKind = m.get(Vocabulary.SUBKIND) if self.subKind is None and m.get(Vocabulary.KIND) != Vocabulary.TaskProgressEvent_CLASS: @@ -4609,9 +4339,10 @@ def fromJson(self, m): @classmethod def createFromJson(cls, m): + import tercen.model.impl as impl kind = m.get(Vocabulary.KIND) if kind == Vocabulary.TaskProgressEvent_CLASS: - return TaskProgressEvent(m) + return impl.TaskProgressEvent(m) raise ValueError("bad kind : " + kind + " for class TaskProgressEvent in createFromJson") @@ -4628,64 +4359,60 @@ def toJson(self): return m -class TaskProgressEvent(TaskProgressEventBase): - def __init__(self, m=None): - super().__init__(m) - - -class CrosstabBase(StepModel): +class CrosstabBase: def __init__(self, m=None): import tercen.model.impl as impl - if ("StepModel", impl.StepModel) in inspect.getmembers(impl): - CrosstabBase.__bases__ = (impl.StepModel,) + CrosstabBase.__bases__ = (impl.StepModel,) if m is None: super().__init__(m) self.taskId = "" - self.axis = XYAxisList() - self.columnTable = CrosstabTable() - self.filters = Filters() - self.operatorSettings = OperatorSettings() - self.rowTable = CrosstabTable() + self.axis = impl.XYAxisList() + self.columnTable = impl.CrosstabTable() + self.filters = impl.Filters() + self.operatorSettings = impl.OperatorSettings() + self.rowTable = impl.CrosstabTable() else: self.fromJson(m) def fromJson(self, m): + import tercen.model.impl as impl super().fromJson(m) self.subKind = m.get(Vocabulary.SUBKIND) if self.subKind is None and m.get(Vocabulary.KIND) != Vocabulary.Crosstab_CLASS: self.subKind = m.get(Vocabulary.KIND) self.taskId = m[Vocabulary.taskId_DP] if m.get(Vocabulary.axis_OP) is None: - self.axis = XYAxisList() + self.axis = impl.XYAxisList() else: self.axis = XYAxisListBase.createFromJson( m.get(Vocabulary.axis_OP)) if m.get(Vocabulary.columnTable_OP) is None: - self.columnTable = CrosstabTable() + self.columnTable = impl.CrosstabTable() else: self.columnTable = CrosstabTableBase.createFromJson( m.get(Vocabulary.columnTable_OP)) if m.get(Vocabulary.filters_OP) is None: - self.filters = Filters() + self.filters = impl.Filters() else: self.filters = FiltersBase.createFromJson( m.get(Vocabulary.filters_OP)) if m.get(Vocabulary.operatorSettings_OP) is None: - self.operatorSettings = OperatorSettings() + self.operatorSettings = impl.OperatorSettings() else: self.operatorSettings = OperatorSettingsBase.createFromJson( m.get(Vocabulary.operatorSettings_OP)) if m.get(Vocabulary.rowTable_OP) is None: - self.rowTable = CrosstabTable() + self.rowTable = impl.CrosstabTable() else: self.rowTable = CrosstabTableBase.createFromJson( m.get(Vocabulary.rowTable_OP)) @classmethod def createFromJson(cls, m): + import tercen.model.impl as impl kind = m.get(Vocabulary.KIND) if kind == Vocabulary.Crosstab_CLASS: - return Crosstab(m) + return impl.Crosstab(m) raise ValueError("bad kind : " + kind + " for class Crosstab in createFromJson") @@ -4705,16 +4432,10 @@ def toJson(self): return m -class Crosstab(CrosstabBase): - def __init__(self, m=None): - super().__init__(m) - - -class ProjectDocumentBase(Document): +class ProjectDocumentBase: def __init__(self, m=None): import tercen.model.impl as impl - if ("Document", impl.Document) in inspect.getmembers(impl): - ProjectDocumentBase.__bases__ = (impl.Document,) + ProjectDocumentBase.__bases__ = (impl.Document,) if m is None: super().__init__(m) self.projectId = "" @@ -4723,6 +4444,7 @@ def __init__(self, m=None): self.fromJson(m) def fromJson(self, m): + import tercen.model.impl as impl super().fromJson(m) self.subKind = m.get(Vocabulary.SUBKIND) if self.subKind is None and m.get(Vocabulary.KIND) != Vocabulary.ProjectDocument_CLASS: @@ -4732,27 +4454,28 @@ def fromJson(self, m): @classmethod def createFromJson(cls, m): + import tercen.model.impl as impl kind = m.get(Vocabulary.KIND) if kind == Vocabulary.ProjectDocument_CLASS: - return ProjectDocument(m) + return impl.ProjectDocument(m) if kind == Vocabulary.CubeQueryTableSchema_CLASS: - return CubeQueryTableSchema(m) + return impl.CubeQueryTableSchema(m) if kind == Vocabulary.TableSchema_CLASS: - return TableSchema(m) + return impl.TableSchema(m) if kind == Vocabulary.ComputedTableSchema_CLASS: - return ComputedTableSchema(m) + return impl.ComputedTableSchema(m) if kind == Vocabulary.Issue_CLASS: - return Issue(m) + return impl.Issue(m) if kind == Vocabulary.FileDocument_CLASS: - return FileDocument(m) + return impl.FileDocument(m) if kind == Vocabulary.FolderDocument_CLASS: - return FolderDocument(m) + return impl.FolderDocument(m) if kind == Vocabulary.Schema_CLASS: - return Schema(m) + return impl.Schema(m) if kind == Vocabulary.IssueMessage_CLASS: - return IssueMessage(m) + return impl.IssueMessage(m) if kind == Vocabulary.Workflow_CLASS: - return Workflow(m) + return impl.Workflow(m) raise ValueError("bad kind : " + kind + " for class ProjectDocument in createFromJson") @@ -4768,16 +4491,10 @@ def toJson(self): return m -class ProjectDocument(ProjectDocumentBase): - def __init__(self, m=None): - super().__init__(m) - - -class IssueBase(ProjectDocument): +class IssueBase: def __init__(self, m=None): import tercen.model.impl as impl - if ("ProjectDocument", impl.ProjectDocument) in inspect.getmembers(impl): - IssueBase.__bases__ = (impl.ProjectDocument,) + IssueBase.__bases__ = (impl.ProjectDocument,) if m is not None: self.fromJson(m) @@ -4785,6 +4502,7 @@ def __init__(self, m=None): super().__init__(m) def fromJson(self, m): + import tercen.model.impl as impl super().fromJson(m) self.subKind = m.get(Vocabulary.SUBKIND) if self.subKind is None and m.get(Vocabulary.KIND) != Vocabulary.Issue_CLASS: @@ -4792,9 +4510,10 @@ def fromJson(self, m): @classmethod def createFromJson(cls, m): + import tercen.model.impl as impl kind = m.get(Vocabulary.KIND) if kind == Vocabulary.Issue_CLASS: - return Issue(m) + return impl.Issue(m) raise ValueError("bad kind : " + kind + " for class Issue in createFromJson") @@ -4808,16 +4527,10 @@ def toJson(self): return m -class Issue(IssueBase): - def __init__(self, m=None): - super().__init__(m) - - -class PatchRecordBase(SciObject): +class PatchRecordBase: def __init__(self, m=None): import tercen.model.impl as impl - if ("SciObject", impl.SciObject) in inspect.getmembers(impl): - PatchRecordBase.__bases__ = (impl.SciObject,) + PatchRecordBase.__bases__ = (impl.SciObject,) if m is None: super().__init__(m) self.p = "" @@ -4827,6 +4540,7 @@ def __init__(self, m=None): self.fromJson(m) def fromJson(self, m): + import tercen.model.impl as impl super().fromJson(m) self.subKind = m.get(Vocabulary.SUBKIND) if self.subKind is None and m.get(Vocabulary.KIND) != Vocabulary.PatchRecord_CLASS: @@ -4837,9 +4551,10 @@ def fromJson(self, m): @classmethod def createFromJson(cls, m): + import tercen.model.impl as impl kind = m.get(Vocabulary.KIND) if kind == Vocabulary.PatchRecord_CLASS: - return PatchRecord(m) + return impl.PatchRecord(m) raise ValueError("bad kind : " + kind + " for class PatchRecord in createFromJson") @@ -4856,25 +4571,20 @@ def toJson(self): return m -class PatchRecord(PatchRecordBase): - def __init__(self, m=None): - super().__init__(m) - - -class CubeQueryTaskBase(ProjectTask): +class CubeQueryTaskBase: def __init__(self, m=None): import tercen.model.impl as impl - if ("ProjectTask", impl.ProjectTask) in inspect.getmembers(impl): - CubeQueryTaskBase.__bases__ = (impl.ProjectTask,) + CubeQueryTaskBase.__bases__ = (impl.ProjectTask,) if m is None: super().__init__(m) self.removeOnGC = True self.schemaIds = list() - self.query = CubeQuery() + self.query = impl.CubeQuery() else: self.fromJson(m) def fromJson(self, m): + import tercen.model.impl as impl super().fromJson(m) self.subKind = m.get(Vocabulary.SUBKIND) if self.subKind is None and m.get(Vocabulary.KIND) != Vocabulary.CubeQueryTask_CLASS: @@ -4885,22 +4595,23 @@ def fromJson(self, m): else: self.schemaIds = m[Vocabulary.schemaIds_DP] if m.get(Vocabulary.query_OP) is None: - self.query = CubeQuery() + self.query = impl.CubeQuery() else: self.query = CubeQueryBase.createFromJson( m.get(Vocabulary.query_OP)) @classmethod def createFromJson(cls, m): + import tercen.model.impl as impl kind = m.get(Vocabulary.KIND) if kind == Vocabulary.CubeQueryTask_CLASS: - return CubeQueryTask(m) + return impl.CubeQueryTask(m) if kind == Vocabulary.RunComputationTask_CLASS: - return RunComputationTask(m) + return impl.RunComputationTask(m) if kind == Vocabulary.SaveComputationResultTask_CLASS: - return SaveComputationResultTask(m) + return impl.SaveComputationResultTask(m) if kind == Vocabulary.ComputationTask_CLASS: - return ComputationTask(m) + return impl.ComputationTask(m) raise ValueError("bad kind : " + kind + " for class CubeQueryTask in createFromJson") @@ -4917,25 +4628,20 @@ def toJson(self): return m -class CubeQueryTask(CubeQueryTaskBase): - def __init__(self, m=None): - super().__init__(m) - - -class ComputationTaskBase(CubeQueryTask): +class ComputationTaskBase: def __init__(self, m=None): import tercen.model.impl as impl - if ("CubeQueryTask", impl.CubeQueryTask) in inspect.getmembers(impl): - ComputationTaskBase.__bases__ = (impl.CubeQueryTask,) + ComputationTaskBase.__bases__ = (impl.CubeQueryTask,) if m is None: super().__init__(m) self.parentTaskId = "" self.fileResultId = "" - self.computedRelation = Relation() + self.computedRelation = impl.Relation() else: self.fromJson(m) def fromJson(self, m): + import tercen.model.impl as impl super().fromJson(m) self.subKind = m.get(Vocabulary.SUBKIND) if self.subKind is None and m.get(Vocabulary.KIND) != Vocabulary.ComputationTask_CLASS: @@ -4943,20 +4649,21 @@ def fromJson(self, m): self.parentTaskId = m[Vocabulary.parentTaskId_DP] self.fileResultId = m[Vocabulary.fileResultId_DP] if m.get(Vocabulary.computedRelation_OP) is None: - self.computedRelation = Relation() + self.computedRelation = impl.Relation() else: self.computedRelation = RelationBase.createFromJson( m.get(Vocabulary.computedRelation_OP)) @classmethod def createFromJson(cls, m): + import tercen.model.impl as impl kind = m.get(Vocabulary.KIND) if kind == Vocabulary.ComputationTask_CLASS: - return ComputationTask(m) + return impl.ComputationTask(m) if kind == Vocabulary.RunComputationTask_CLASS: - return RunComputationTask(m) + return impl.RunComputationTask(m) if kind == Vocabulary.SaveComputationResultTask_CLASS: - return SaveComputationResultTask(m) + return impl.SaveComputationResultTask(m) raise ValueError("bad kind : " + kind + " for class ComputationTask in createFromJson") @@ -4973,16 +4680,10 @@ def toJson(self): return m -class ComputationTask(ComputationTaskBase): - def __init__(self, m=None): - super().__init__(m) - - -class SaveComputationResultTaskBase(ComputationTask): +class SaveComputationResultTaskBase: def __init__(self, m=None): import tercen.model.impl as impl - if ("ComputationTask", impl.ComputationTask) in inspect.getmembers(impl): - SaveComputationResultTaskBase.__bases__ = (impl.ComputationTask,) + SaveComputationResultTaskBase.__bases__ = (impl.ComputationTask,) if m is not None: self.fromJson(m) @@ -4990,6 +4691,7 @@ def __init__(self, m=None): super().__init__(m) def fromJson(self, m): + import tercen.model.impl as impl super().fromJson(m) self.subKind = m.get(Vocabulary.SUBKIND) if self.subKind is None and m.get(Vocabulary.KIND) != Vocabulary.SaveComputationResultTask_CLASS: @@ -4997,11 +4699,12 @@ def fromJson(self, m): @classmethod def createFromJson(cls, m): + import tercen.model.impl as impl kind = m.get(Vocabulary.KIND) if kind == Vocabulary.SaveComputationResultTask_CLASS: - return SaveComputationResultTask(m) + return impl.SaveComputationResultTask(m) if kind == Vocabulary.RunComputationTask_CLASS: - return RunComputationTask(m) + return impl.RunComputationTask(m) raise ValueError("bad kind : " + kind + " for class SaveComputationResultTask in createFromJson") @@ -5015,17 +4718,10 @@ def toJson(self): return m -class SaveComputationResultTask(SaveComputationResultTaskBase): - def __init__(self, m=None): - super().__init__(m) - - -class RunComputationTaskBase(SaveComputationResultTask): +class RunComputationTaskBase: def __init__(self, m=None): import tercen.model.impl as impl - if ("SaveComputationResultTask", impl.SaveComputationResultTask) in inspect.getmembers(impl): - RunComputationTaskBase.__bases__ = ( - impl.SaveComputationResultTask,) + RunComputationTaskBase.__bases__ = (impl.SaveComputationResultTask,) if m is not None: self.fromJson(m) @@ -5033,6 +4729,7 @@ def __init__(self, m=None): super().__init__(m) def fromJson(self, m): + import tercen.model.impl as impl super().fromJson(m) self.subKind = m.get(Vocabulary.SUBKIND) if self.subKind is None and m.get(Vocabulary.KIND) != Vocabulary.RunComputationTask_CLASS: @@ -5040,9 +4737,10 @@ def fromJson(self, m): @classmethod def createFromJson(cls, m): + import tercen.model.impl as impl kind = m.get(Vocabulary.KIND) if kind == Vocabulary.RunComputationTask_CLASS: - return RunComputationTask(m) + return impl.RunComputationTask(m) raise ValueError("bad kind : " + kind + " for class RunComputationTask in createFromJson") @@ -5056,16 +4754,10 @@ def toJson(self): return m -class RunComputationTask(RunComputationTaskBase): - def __init__(self, m=None): - super().__init__(m) - - -class WorkerEndpointBase(Document): +class WorkerEndpointBase: def __init__(self, m=None): import tercen.model.impl as impl - if ("Document", impl.Document) in inspect.getmembers(impl): - WorkerEndpointBase.__bases__ = (impl.Document,) + WorkerEndpointBase.__bases__ = (impl.Document,) if m is None: super().__init__(m) self.uri = "" @@ -5073,6 +4765,7 @@ def __init__(self, m=None): self.fromJson(m) def fromJson(self, m): + import tercen.model.impl as impl super().fromJson(m) self.subKind = m.get(Vocabulary.SUBKIND) if self.subKind is None and m.get(Vocabulary.KIND) != Vocabulary.WorkerEndpoint_CLASS: @@ -5081,9 +4774,10 @@ def fromJson(self, m): @classmethod def createFromJson(cls, m): + import tercen.model.impl as impl kind = m.get(Vocabulary.KIND) if kind == Vocabulary.WorkerEndpoint_CLASS: - return WorkerEndpoint(m) + return impl.WorkerEndpoint(m) raise ValueError("bad kind : " + kind + " for class WorkerEndpoint in createFromJson") @@ -5098,16 +4792,10 @@ def toJson(self): return m -class WorkerEndpoint(WorkerEndpointBase): - def __init__(self, m=None): - super().__init__(m) - - -class ColumnSchemaMetaDataBase(SciObject): +class ColumnSchemaMetaDataBase: def __init__(self, m=None): import tercen.model.impl as impl - if ("SciObject", impl.SciObject) in inspect.getmembers(impl): - ColumnSchemaMetaDataBase.__bases__ = (impl.SciObject,) + ColumnSchemaMetaDataBase.__bases__ = (impl.SciObject,) if m is None: super().__init__(m) self.sort = list() @@ -5118,6 +4806,7 @@ def __init__(self, m=None): self.fromJson(m) def fromJson(self, m): + import tercen.model.impl as impl super().fromJson(m) self.subKind = m.get(Vocabulary.SUBKIND) if self.subKind is None and m.get(Vocabulary.KIND) != Vocabulary.ColumnSchemaMetaData_CLASS: @@ -5140,9 +4829,10 @@ def fromJson(self, m): @classmethod def createFromJson(cls, m): + import tercen.model.impl as impl kind = m.get(Vocabulary.KIND) if kind == Vocabulary.ColumnSchemaMetaData_CLASS: - return ColumnSchemaMetaData(m) + return impl.ColumnSchemaMetaData(m) raise ValueError("bad kind : " + kind + " for class ColumnSchemaMetaData in createFromJson") @@ -5161,16 +4851,10 @@ def toJson(self): return m -class ColumnSchemaMetaData(ColumnSchemaMetaDataBase): - def __init__(self, m=None): - super().__init__(m) - - -class PrivilegeBase(SciObject): +class PrivilegeBase: def __init__(self, m=None): import tercen.model.impl as impl - if ("SciObject", impl.SciObject) in inspect.getmembers(impl): - PrivilegeBase.__bases__ = (impl.SciObject,) + PrivilegeBase.__bases__ = (impl.SciObject,) if m is None: super().__init__(m) self.type = "" @@ -5178,6 +4862,7 @@ def __init__(self, m=None): self.fromJson(m) def fromJson(self, m): + import tercen.model.impl as impl super().fromJson(m) self.subKind = m.get(Vocabulary.SUBKIND) if self.subKind is None and m.get(Vocabulary.KIND) != Vocabulary.Privilege_CLASS: @@ -5186,9 +4871,10 @@ def fromJson(self, m): @classmethod def createFromJson(cls, m): + import tercen.model.impl as impl kind = m.get(Vocabulary.KIND) if kind == Vocabulary.Privilege_CLASS: - return Privilege(m) + return impl.Privilege(m) raise ValueError("bad kind : " + kind + " for class Privilege in createFromJson") @@ -5203,16 +4889,10 @@ def toJson(self): return m -class Privilege(PrivilegeBase): - def __init__(self, m=None): - super().__init__(m) - - -class CSVTaskBase(ProjectTask): +class CSVTaskBase: def __init__(self, m=None): import tercen.model.impl as impl - if ("ProjectTask", impl.ProjectTask) in inspect.getmembers(impl): - CSVTaskBase.__bases__ = (impl.ProjectTask,) + CSVTaskBase.__bases__ = (impl.ProjectTask,) if m is None: super().__init__(m) self.fileDocumentId = "" @@ -5220,12 +4900,13 @@ def __init__(self, m=None): self.valueName = "" self.variableName = "" self.gatherNames = list() - self.schema = Schema() - self.params = CSVParserParam() + self.schema = impl.Schema() + self.params = impl.CSVParserParam() else: self.fromJson(m) def fromJson(self, m): + import tercen.model.impl as impl super().fromJson(m) self.subKind = m.get(Vocabulary.SUBKIND) if self.subKind is None and m.get(Vocabulary.KIND) != Vocabulary.CSVTask_CLASS: @@ -5239,21 +4920,22 @@ def fromJson(self, m): else: self.gatherNames = m[Vocabulary.gatherNames_DP] if m.get(Vocabulary.schema_OP) is None: - self.schema = Schema() + self.schema = impl.Schema() else: self.schema = SchemaBase.createFromJson( m.get(Vocabulary.schema_OP)) if m.get(Vocabulary.params_OP) is None: - self.params = CSVParserParam() + self.params = impl.CSVParserParam() else: self.params = CSVParserParamBase.createFromJson( m.get(Vocabulary.params_OP)) @classmethod def createFromJson(cls, m): + import tercen.model.impl as impl kind = m.get(Vocabulary.KIND) if kind == Vocabulary.CSVTask_CLASS: - return CSVTask(m) + return impl.CSVTask(m) raise ValueError("bad kind : " + kind + " for class CSVTask in createFromJson") @@ -5274,16 +4956,10 @@ def toJson(self): return m -class CSVTask(CSVTaskBase): - def __init__(self, m=None): - super().__init__(m) - - -class ActivityBase(PersistentObject): +class ActivityBase: def __init__(self, m=None): import tercen.model.impl as impl - if ("PersistentObject", impl.PersistentObject) in inspect.getmembers(impl): - ActivityBase.__bases__ = (impl.PersistentObject,) + ActivityBase.__bases__ = (impl.PersistentObject,) if m is None: super().__init__(m) self.type = "" @@ -5293,12 +4969,13 @@ def __init__(self, m=None): self.userId = "" self.projectName = "" self.isPublic = True - self.date = Date() + self.date = impl.Date() self.properties = list() else: self.fromJson(m) def fromJson(self, m): + import tercen.model.impl as impl super().fromJson(m) self.subKind = m.get(Vocabulary.SUBKIND) if self.subKind is None and m.get(Vocabulary.KIND) != Vocabulary.Activity_CLASS: @@ -5311,7 +4988,7 @@ def fromJson(self, m): self.projectName = m[Vocabulary.projectName_DP] self.isPublic = m[Vocabulary.isPublic_DP] if m.get(Vocabulary.date_OP) is None: - self.date = Date() + self.date = impl.Date() else: self.date = DateBase.createFromJson(m.get(Vocabulary.date_OP)) if m.get(Vocabulary.properties_OP) is None: @@ -5323,9 +5000,10 @@ def fromJson(self, m): @classmethod def createFromJson(cls, m): + import tercen.model.impl as impl kind = m.get(Vocabulary.KIND) if kind == Vocabulary.Activity_CLASS: - return Activity(m) + return impl.Activity(m) raise ValueError("bad kind : " + kind + " for class Activity in createFromJson") @@ -5349,16 +5027,10 @@ def toJson(self): return m -class Activity(ActivityBase): - def __init__(self, m=None): - super().__init__(m) - - -class ViesInfoBase(SciObject): +class ViesInfoBase: def __init__(self, m=None): import tercen.model.impl as impl - if ("SciObject", impl.SciObject) in inspect.getmembers(impl): - ViesInfoBase.__bases__ = (impl.SciObject,) + ViesInfoBase.__bases__ = (impl.SciObject,) if m is None: super().__init__(m) self.countryCode = "" @@ -5371,6 +5043,7 @@ def __init__(self, m=None): self.fromJson(m) def fromJson(self, m): + import tercen.model.impl as impl super().fromJson(m) self.subKind = m.get(Vocabulary.SUBKIND) if self.subKind is None and m.get(Vocabulary.KIND) != Vocabulary.ViesInfo_CLASS: @@ -5384,9 +5057,10 @@ def fromJson(self, m): @classmethod def createFromJson(cls, m): + import tercen.model.impl as impl kind = m.get(Vocabulary.KIND) if kind == Vocabulary.ViesInfo_CLASS: - return ViesInfo(m) + return impl.ViesInfo(m) raise ValueError("bad kind : " + kind + " for class ViesInfo in createFromJson") @@ -5406,16 +5080,10 @@ def toJson(self): return m -class ViesInfo(ViesInfoBase): - def __init__(self, m=None): - super().__init__(m) - - -class JoinStepModelBase(StepModel): +class JoinStepModelBase: def __init__(self, m=None): import tercen.model.impl as impl - if ("StepModel", impl.StepModel) in inspect.getmembers(impl): - JoinStepModelBase.__bases__ = (impl.StepModel,) + JoinStepModelBase.__bases__ = (impl.StepModel,) if m is None: super().__init__(m) self.rightPrefix = "" @@ -5426,6 +5094,7 @@ def __init__(self, m=None): self.fromJson(m) def fromJson(self, m): + import tercen.model.impl as impl super().fromJson(m) self.subKind = m.get(Vocabulary.SUBKIND) if self.subKind is None and m.get(Vocabulary.KIND) != Vocabulary.JoinStepModel_CLASS: @@ -5447,9 +5116,10 @@ def fromJson(self, m): @classmethod def createFromJson(cls, m): + import tercen.model.impl as impl kind = m.get(Vocabulary.KIND) if kind == Vocabulary.JoinStepModel_CLASS: - return JoinStepModel(m) + return impl.JoinStepModel(m) raise ValueError("bad kind : " + kind + " for class JoinStepModel in createFromJson") @@ -5469,13 +5139,9 @@ def toJson(self): return m -class JoinStepModel(JoinStepModelBase): - def __init__(self, m=None): - super().__init__(m) - - -class UlimitsBase(BaseObject): +class UlimitsBase: def __init__(self, m=None): + import tercen.model.impl as impl if m is None: super().__init__(m) self.core_file_size = 0 @@ -5498,6 +5164,7 @@ def __init__(self, m=None): self.fromJson(m) def fromJson(self, m): + import tercen.model.impl as impl super().fromJson(m) self.subKind = m.get(Vocabulary.SUBKIND) if self.subKind is None and m.get(Vocabulary.KIND) != Vocabulary.Ulimits_CLASS: @@ -5521,9 +5188,10 @@ def fromJson(self, m): @classmethod def createFromJson(cls, m): + import tercen.model.impl as impl kind = m.get(Vocabulary.KIND) if kind == Vocabulary.Ulimits_CLASS: - return Ulimits(m) + return impl.Ulimits(m) raise ValueError("bad kind : " + kind + " for class Ulimits in createFromJson") @@ -5553,16 +5221,10 @@ def toJson(self): return m -class Ulimits(UlimitsBase): - def __init__(self, m=None): - super().__init__(m) - - -class RDescriptionBase(SciObject): +class RDescriptionBase: def __init__(self, m=None): import tercen.model.impl as impl - if ("SciObject", impl.SciObject) in inspect.getmembers(impl): - RDescriptionBase.__bases__ = (impl.SciObject,) + RDescriptionBase.__bases__ = (impl.SciObject,) if m is None: super().__init__(m) self.Package = "" @@ -5578,6 +5240,7 @@ def __init__(self, m=None): self.fromJson(m) def fromJson(self, m): + import tercen.model.impl as impl super().fromJson(m) self.subKind = m.get(Vocabulary.SUBKIND) if self.subKind is None and m.get(Vocabulary.KIND) != Vocabulary.RDescription_CLASS: @@ -5594,9 +5257,10 @@ def fromJson(self, m): @classmethod def createFromJson(cls, m): + import tercen.model.impl as impl kind = m.get(Vocabulary.KIND) if kind == Vocabulary.RDescription_CLASS: - return RDescription(m) + return impl.RDescription(m) raise ValueError("bad kind : " + kind + " for class RDescription in createFromJson") @@ -5619,16 +5283,10 @@ def toJson(self): return m -class RDescription(RDescriptionBase): - def __init__(self, m=None): - super().__init__(m) - - -class JetPaletteBase(RampPalette): +class JetPaletteBase: def __init__(self, m=None): import tercen.model.impl as impl - if ("RampPalette", impl.RampPalette) in inspect.getmembers(impl): - JetPaletteBase.__bases__ = (impl.RampPalette,) + JetPaletteBase.__bases__ = (impl.RampPalette,) if m is not None: self.fromJson(m) @@ -5636,6 +5294,7 @@ def __init__(self, m=None): super().__init__(m) def fromJson(self, m): + import tercen.model.impl as impl super().fromJson(m) self.subKind = m.get(Vocabulary.SUBKIND) if self.subKind is None and m.get(Vocabulary.KIND) != Vocabulary.JetPalette_CLASS: @@ -5643,9 +5302,10 @@ def fromJson(self, m): @classmethod def createFromJson(cls, m): + import tercen.model.impl as impl kind = m.get(Vocabulary.KIND) if kind == Vocabulary.JetPalette_CLASS: - return JetPalette(m) + return impl.JetPalette(m) raise ValueError("bad kind : " + kind + " for class JetPalette in createFromJson") @@ -5659,16 +5319,10 @@ def toJson(self): return m -class JetPalette(JetPaletteBase): - def __init__(self, m=None): - super().__init__(m) - - -class SimpleRelationBase(Relation): +class SimpleRelationBase: def __init__(self, m=None): import tercen.model.impl as impl - if ("Relation", impl.Relation) in inspect.getmembers(impl): - SimpleRelationBase.__bases__ = (impl.Relation,) + SimpleRelationBase.__bases__ = (impl.Relation,) if m is None: super().__init__(m) self.index = 0 @@ -5676,6 +5330,7 @@ def __init__(self, m=None): self.fromJson(m) def fromJson(self, m): + import tercen.model.impl as impl super().fromJson(m) self.subKind = m.get(Vocabulary.SUBKIND) if self.subKind is None and m.get(Vocabulary.KIND) != Vocabulary.SimpleRelation_CLASS: @@ -5684,11 +5339,12 @@ def fromJson(self, m): @classmethod def createFromJson(cls, m): + import tercen.model.impl as impl kind = m.get(Vocabulary.KIND) if kind == Vocabulary.SimpleRelation_CLASS: - return SimpleRelation(m) + return impl.SimpleRelation(m) if kind == Vocabulary.TableRelation_CLASS: - return TableRelation(m) + return impl.TableRelation(m) raise ValueError("bad kind : " + kind + " for class SimpleRelation in createFromJson") @@ -5703,16 +5359,10 @@ def toJson(self): return m -class SimpleRelation(SimpleRelationBase): - def __init__(self, m=None): - super().__init__(m) - - -class TableRelationBase(SimpleRelation): +class TableRelationBase: def __init__(self, m=None): import tercen.model.impl as impl - if ("SimpleRelation", impl.SimpleRelation) in inspect.getmembers(impl): - TableRelationBase.__bases__ = (impl.SimpleRelation,) + TableRelationBase.__bases__ = (impl.SimpleRelation,) if m is None: super().__init__(m) self.nRows = 0 @@ -5723,6 +5373,7 @@ def __init__(self, m=None): self.fromJson(m) def fromJson(self, m): + import tercen.model.impl as impl super().fromJson(m) self.subKind = m.get(Vocabulary.SUBKIND) if self.subKind is None and m.get(Vocabulary.KIND) != Vocabulary.TableRelation_CLASS: @@ -5744,9 +5395,10 @@ def fromJson(self, m): @classmethod def createFromJson(cls, m): + import tercen.model.impl as impl kind = m.get(Vocabulary.KIND) if kind == Vocabulary.TableRelation_CLASS: - return TableRelation(m) + return impl.TableRelation(m) raise ValueError("bad kind : " + kind + " for class TableRelation in createFromJson") @@ -5766,16 +5418,10 @@ def toJson(self): return m -class TableRelation(TableRelationBase): - def __init__(self, m=None): - super().__init__(m) - - -class DateBase(SciObject): +class DateBase: def __init__(self, m=None): import tercen.model.impl as impl - if ("SciObject", impl.SciObject) in inspect.getmembers(impl): - DateBase.__bases__ = (impl.SciObject,) + DateBase.__bases__ = (impl.SciObject,) if m is None: super().__init__(m) self.value = "" @@ -5783,6 +5429,7 @@ def __init__(self, m=None): self.fromJson(m) def fromJson(self, m): + import tercen.model.impl as impl super().fromJson(m) self.subKind = m.get(Vocabulary.SUBKIND) if self.subKind is None and m.get(Vocabulary.KIND) != Vocabulary.Date_CLASS: @@ -5791,9 +5438,10 @@ def fromJson(self, m): @classmethod def createFromJson(cls, m): + import tercen.model.impl as impl kind = m.get(Vocabulary.KIND) if kind == Vocabulary.Date_CLASS: - return Date(m) + return impl.Date(m) raise ValueError("bad kind : " + kind + " for class Date in createFromJson") @@ -5808,40 +5456,36 @@ def toJson(self): return m -class Date(DateBase): - def __init__(self, m=None): - super().__init__(m) - - -class StepStateBase(SciObject): +class StepStateBase: def __init__(self, m=None): import tercen.model.impl as impl - if ("SciObject", impl.SciObject) in inspect.getmembers(impl): - StepStateBase.__bases__ = (impl.SciObject,) + StepStateBase.__bases__ = (impl.SciObject,) if m is None: super().__init__(m) self.taskId = "" - self.taskState = State() + self.taskState = impl.State() else: self.fromJson(m) def fromJson(self, m): + import tercen.model.impl as impl super().fromJson(m) self.subKind = m.get(Vocabulary.SUBKIND) if self.subKind is None and m.get(Vocabulary.KIND) != Vocabulary.StepState_CLASS: self.subKind = m.get(Vocabulary.KIND) self.taskId = m[Vocabulary.taskId_DP] if m.get(Vocabulary.taskState_OP) is None: - self.taskState = State() + self.taskState = impl.State() else: self.taskState = StateBase.createFromJson( m.get(Vocabulary.taskState_OP)) @classmethod def createFromJson(cls, m): + import tercen.model.impl as impl kind = m.get(Vocabulary.KIND) if kind == Vocabulary.StepState_CLASS: - return StepState(m) + return impl.StepState(m) raise ValueError("bad kind : " + kind + " for class StepState in createFromJson") @@ -5857,16 +5501,10 @@ def toJson(self): return m -class StepState(StepStateBase): - def __init__(self, m=None): - super().__init__(m) - - -class OperatorResultBase(SciObject): +class OperatorResultBase: def __init__(self, m=None): import tercen.model.impl as impl - if ("SciObject", impl.SciObject) in inspect.getmembers(impl): - OperatorResultBase.__bases__ = (impl.SciObject,) + OperatorResultBase.__bases__ = (impl.SciObject,) if m is None: super().__init__(m) self.tables = list() @@ -5875,6 +5513,7 @@ def __init__(self, m=None): self.fromJson(m) def fromJson(self, m): + import tercen.model.impl as impl super().fromJson(m) self.subKind = m.get(Vocabulary.SUBKIND) if self.subKind is None and m.get(Vocabulary.KIND) != Vocabulary.OperatorResult_CLASS: @@ -5894,9 +5533,10 @@ def fromJson(self, m): @classmethod def createFromJson(cls, m): + import tercen.model.impl as impl kind = m.get(Vocabulary.KIND) if kind == Vocabulary.OperatorResult_CLASS: - return OperatorResult(m) + return impl.OperatorResult(m) raise ValueError("bad kind : " + kind + " for class OperatorResult in createFromJson") @@ -5913,16 +5553,10 @@ def toJson(self): return m -class OperatorResult(OperatorResultBase): - def __init__(self, m=None): - super().__init__(m) - - -class RSourceLibraryBase(RLibrary): +class RSourceLibraryBase: def __init__(self, m=None): import tercen.model.impl as impl - if ("RLibrary", impl.RLibrary) in inspect.getmembers(impl): - RSourceLibraryBase.__bases__ = (impl.RLibrary,) + RSourceLibraryBase.__bases__ = (impl.RLibrary,) if m is None: super().__init__(m) self.fileId = "" @@ -5930,6 +5564,7 @@ def __init__(self, m=None): self.fromJson(m) def fromJson(self, m): + import tercen.model.impl as impl super().fromJson(m) self.subKind = m.get(Vocabulary.SUBKIND) if self.subKind is None and m.get(Vocabulary.KIND) != Vocabulary.RSourceLibrary_CLASS: @@ -5938,9 +5573,10 @@ def fromJson(self, m): @classmethod def createFromJson(cls, m): + import tercen.model.impl as impl kind = m.get(Vocabulary.KIND) if kind == Vocabulary.RSourceLibrary_CLASS: - return RSourceLibrary(m) + return impl.RSourceLibrary(m) raise ValueError("bad kind : " + kind + " for class RSourceLibrary in createFromJson") @@ -5955,25 +5591,20 @@ def toJson(self): return m -class RSourceLibrary(RSourceLibraryBase): - def __init__(self, m=None): - super().__init__(m) - - -class FileDocumentBase(ProjectDocument): +class FileDocumentBase: def __init__(self, m=None): import tercen.model.impl as impl - if ("ProjectDocument", impl.ProjectDocument) in inspect.getmembers(impl): - FileDocumentBase.__bases__ = (impl.ProjectDocument,) + FileDocumentBase.__bases__ = (impl.ProjectDocument,) if m is None: super().__init__(m) self.dataUri = "" self.size = 0 - self.metadata = FileMetadata() + self.metadata = impl.FileMetadata() else: self.fromJson(m) def fromJson(self, m): + import tercen.model.impl as impl super().fromJson(m) self.subKind = m.get(Vocabulary.SUBKIND) if self.subKind is None and m.get(Vocabulary.KIND) != Vocabulary.FileDocument_CLASS: @@ -5981,16 +5612,17 @@ def fromJson(self, m): self.dataUri = m[Vocabulary.dataUri_DP] self.size = m[Vocabulary.size_DP] if m.get(Vocabulary.metadata_OP) is None: - self.metadata = FileMetadata() + self.metadata = impl.FileMetadata() else: self.metadata = FileMetadataBase.createFromJson( m.get(Vocabulary.metadata_OP)) @classmethod def createFromJson(cls, m): + import tercen.model.impl as impl kind = m.get(Vocabulary.KIND) if kind == Vocabulary.FileDocument_CLASS: - return FileDocument(m) + return impl.FileDocument(m) raise ValueError("bad kind : " + kind + " for class FileDocument in createFromJson") @@ -6007,16 +5639,10 @@ def toJson(self): return m -class FileDocument(FileDocumentBase): - def __init__(self, m=None): - super().__init__(m) - - -class AddressBase(SciObject): +class AddressBase: def __init__(self, m=None): import tercen.model.impl as impl - if ("SciObject", impl.SciObject) in inspect.getmembers(impl): - AddressBase.__bases__ = (impl.SciObject,) + AddressBase.__bases__ = (impl.SciObject,) if m is None: super().__init__(m) self.country = "" @@ -6030,6 +5656,7 @@ def __init__(self, m=None): self.fromJson(m) def fromJson(self, m): + import tercen.model.impl as impl super().fromJson(m) self.subKind = m.get(Vocabulary.SUBKIND) if self.subKind is None and m.get(Vocabulary.KIND) != Vocabulary.Address_CLASS: @@ -6044,9 +5671,10 @@ def fromJson(self, m): @classmethod def createFromJson(cls, m): + import tercen.model.impl as impl kind = m.get(Vocabulary.KIND) if kind == Vocabulary.Address_CLASS: - return Address(m) + return impl.Address(m) raise ValueError("bad kind : " + kind + " for class Address in createFromJson") @@ -6067,16 +5695,10 @@ def toJson(self): return m -class Address(AddressBase): - def __init__(self, m=None): - super().__init__(m) - - -class TaskDataEventBase(TaskEvent): +class TaskDataEventBase: def __init__(self, m=None): import tercen.model.impl as impl - if ("TaskEvent", impl.TaskEvent) in inspect.getmembers(impl): - TaskDataEventBase.__bases__ = (impl.TaskEvent,) + TaskDataEventBase.__bases__ = (impl.TaskEvent,) if m is None: super().__init__(m) self.bytes = None @@ -6084,6 +5706,7 @@ def __init__(self, m=None): self.fromJson(m) def fromJson(self, m): + import tercen.model.impl as impl super().fromJson(m) self.subKind = m.get(Vocabulary.SUBKIND) if self.subKind is None and m.get(Vocabulary.KIND) != Vocabulary.TaskDataEvent_CLASS: @@ -6092,9 +5715,10 @@ def fromJson(self, m): @classmethod def createFromJson(cls, m): + import tercen.model.impl as impl kind = m.get(Vocabulary.KIND) if kind == Vocabulary.TaskDataEvent_CLASS: - return TaskDataEvent(m) + return impl.TaskDataEvent(m) raise ValueError("bad kind : " + kind + " for class TaskDataEvent in createFromJson") @@ -6109,16 +5733,10 @@ def toJson(self): return m -class TaskDataEvent(TaskDataEventBase): - def __init__(self, m=None): - super().__init__(m) - - -class StringPropertyBase(Property): +class StringPropertyBase: def __init__(self, m=None): import tercen.model.impl as impl - if ("Property", impl.Property) in inspect.getmembers(impl): - StringPropertyBase.__bases__ = (impl.Property,) + StringPropertyBase.__bases__ = (impl.Property,) if m is None: super().__init__(m) self.defaultValue = "" @@ -6126,6 +5744,7 @@ def __init__(self, m=None): self.fromJson(m) def fromJson(self, m): + import tercen.model.impl as impl super().fromJson(m) self.subKind = m.get(Vocabulary.SUBKIND) if self.subKind is None and m.get(Vocabulary.KIND) != Vocabulary.StringProperty_CLASS: @@ -6134,15 +5753,16 @@ def fromJson(self, m): @classmethod def createFromJson(cls, m): + import tercen.model.impl as impl kind = m.get(Vocabulary.KIND) if kind == Vocabulary.StringProperty_CLASS: - return StringProperty(m) + return impl.StringProperty(m) if kind == Vocabulary.EnumeratedProperty_CLASS: - return EnumeratedProperty(m) + return impl.EnumeratedProperty(m) if kind == Vocabulary.FactorsProperty_CLASS: - return FactorsProperty(m) + return impl.FactorsProperty(m) if kind == Vocabulary.FormulaProperty_CLASS: - return FormulaProperty(m) + return impl.FormulaProperty(m) raise ValueError("bad kind : " + kind + " for class StringProperty in createFromJson") @@ -6157,60 +5777,55 @@ def toJson(self): return m -class StringProperty(StringPropertyBase): - def __init__(self, m=None): - super().__init__(m) - - -class XYAxisBase(SciObject): +class XYAxisBase: def __init__(self, m=None): import tercen.model.impl as impl - if ("SciObject", impl.SciObject) in inspect.getmembers(impl): - XYAxisBase.__bases__ = (impl.SciObject,) + XYAxisBase.__bases__ = (impl.SciObject,) if m is None: super().__init__(m) self.taskId = "" - self.chart = Chart() - self.colors = Colors() - self.errors = Errors() - self.labels = Labels() - self.xAxis = Axis() - self.yAxis = Axis() + self.chart = impl.Chart() + self.colors = impl.Colors() + self.errors = impl.Errors() + self.labels = impl.Labels() + self.xAxis = impl.Axis() + self.yAxis = impl.Axis() self.preprocessors = list() else: self.fromJson(m) def fromJson(self, m): + import tercen.model.impl as impl super().fromJson(m) self.subKind = m.get(Vocabulary.SUBKIND) if self.subKind is None and m.get(Vocabulary.KIND) != Vocabulary.XYAxis_CLASS: self.subKind = m.get(Vocabulary.KIND) self.taskId = m[Vocabulary.taskId_DP] if m.get(Vocabulary.chart_OP) is None: - self.chart = Chart() + self.chart = impl.Chart() else: self.chart = ChartBase.createFromJson(m.get(Vocabulary.chart_OP)) if m.get(Vocabulary.colors_OP) is None: - self.colors = Colors() + self.colors = impl.Colors() else: self.colors = ColorsBase.createFromJson( m.get(Vocabulary.colors_OP)) if m.get(Vocabulary.errors_OP) is None: - self.errors = Errors() + self.errors = impl.Errors() else: self.errors = ErrorsBase.createFromJson( m.get(Vocabulary.errors_OP)) if m.get(Vocabulary.labels_OP) is None: - self.labels = Labels() + self.labels = impl.Labels() else: self.labels = LabelsBase.createFromJson( m.get(Vocabulary.labels_OP)) if m.get(Vocabulary.xAxis_OP) is None: - self.xAxis = Axis() + self.xAxis = impl.Axis() else: self.xAxis = AxisBase.createFromJson(m.get(Vocabulary.xAxis_OP)) if m.get(Vocabulary.yAxis_OP) is None: - self.yAxis = Axis() + self.yAxis = impl.Axis() else: self.yAxis = AxisBase.createFromJson(m.get(Vocabulary.yAxis_OP)) if m.get(Vocabulary.preprocessors_OP) is None: @@ -6222,9 +5837,10 @@ def fromJson(self, m): @classmethod def createFromJson(cls, m): + import tercen.model.impl as impl kind = m.get(Vocabulary.KIND) if kind == Vocabulary.XYAxis_CLASS: - return XYAxis(m) + return impl.XYAxis(m) raise ValueError("bad kind : " + kind + " for class XYAxis in createFromJson") @@ -6247,16 +5863,10 @@ def toJson(self): return m -class XYAxis(XYAxisBase): - def __init__(self, m=None): - super().__init__(m) - - -class PrincipalBase(SciObject): +class PrincipalBase: def __init__(self, m=None): import tercen.model.impl as impl - if ("SciObject", impl.SciObject) in inspect.getmembers(impl): - PrincipalBase.__bases__ = (impl.SciObject,) + PrincipalBase.__bases__ = (impl.SciObject,) if m is None: super().__init__(m) self.principalId = "" @@ -6264,6 +5874,7 @@ def __init__(self, m=None): self.fromJson(m) def fromJson(self, m): + import tercen.model.impl as impl super().fromJson(m) self.subKind = m.get(Vocabulary.SUBKIND) if self.subKind is None and m.get(Vocabulary.KIND) != Vocabulary.Principal_CLASS: @@ -6272,9 +5883,10 @@ def fromJson(self, m): @classmethod def createFromJson(cls, m): + import tercen.model.impl as impl kind = m.get(Vocabulary.KIND) if kind == Vocabulary.Principal_CLASS: - return Principal(m) + return impl.Principal(m) raise ValueError("bad kind : " + kind + " for class Principal in createFromJson") @@ -6289,16 +5901,10 @@ def toJson(self): return m -class Principal(PrincipalBase): - def __init__(self, m=None): - super().__init__(m) - - -class FactorBase(SciObject): +class FactorBase: def __init__(self, m=None): import tercen.model.impl as impl - if ("SciObject", impl.SciObject) in inspect.getmembers(impl): - FactorBase.__bases__ = (impl.SciObject,) + FactorBase.__bases__ = (impl.SciObject,) if m is None: super().__init__(m) self.name = "" @@ -6307,6 +5913,7 @@ def __init__(self, m=None): self.fromJson(m) def fromJson(self, m): + import tercen.model.impl as impl super().fromJson(m) self.subKind = m.get(Vocabulary.SUBKIND) if self.subKind is None and m.get(Vocabulary.KIND) != Vocabulary.Factor_CLASS: @@ -6316,13 +5923,14 @@ def fromJson(self, m): @classmethod def createFromJson(cls, m): + import tercen.model.impl as impl kind = m.get(Vocabulary.KIND) if kind == Vocabulary.Factor_CLASS: - return Factor(m) + return impl.Factor(m) if kind == Vocabulary.Attribute_CLASS: - return Attribute(m) + return impl.Attribute(m) if kind == Vocabulary.MappingFactor_CLASS: - return MappingFactor(m) + return impl.MappingFactor(m) raise ValueError("bad kind : " + kind + " for class Factor in createFromJson") @@ -6338,16 +5946,10 @@ def toJson(self): return m -class Factor(FactorBase): - def __init__(self, m=None): - super().__init__(m) - - -class AttributeBase(Factor): +class AttributeBase: def __init__(self, m=None): import tercen.model.impl as impl - if ("Factor", impl.Factor) in inspect.getmembers(impl): - AttributeBase.__bases__ = (impl.Factor,) + AttributeBase.__bases__ = (impl.Factor,) if m is not None: self.fromJson(m) @@ -6355,6 +5957,7 @@ def __init__(self, m=None): super().__init__(m) def fromJson(self, m): + import tercen.model.impl as impl super().fromJson(m) self.subKind = m.get(Vocabulary.SUBKIND) if self.subKind is None and m.get(Vocabulary.KIND) != Vocabulary.Attribute_CLASS: @@ -6362,9 +5965,10 @@ def fromJson(self, m): @classmethod def createFromJson(cls, m): + import tercen.model.impl as impl kind = m.get(Vocabulary.KIND) if kind == Vocabulary.Attribute_CLASS: - return Attribute(m) + return impl.Attribute(m) raise ValueError("bad kind : " + kind + " for class Attribute in createFromJson") @@ -6378,16 +5982,10 @@ def toJson(self): return m -class Attribute(AttributeBase): - def __init__(self, m=None): - super().__init__(m) - - -class ImportWorkflowTaskBase(ProjectTask): +class ImportWorkflowTaskBase: def __init__(self, m=None): import tercen.model.impl as impl - if ("ProjectTask", impl.ProjectTask) in inspect.getmembers(impl): - ImportWorkflowTaskBase.__bases__ = (impl.ProjectTask,) + ImportWorkflowTaskBase.__bases__ = (impl.ProjectTask,) if m is None: super().__init__(m) self.fileId = "" @@ -6397,6 +5995,7 @@ def __init__(self, m=None): self.fromJson(m) def fromJson(self, m): + import tercen.model.impl as impl super().fromJson(m) self.subKind = m.get(Vocabulary.SUBKIND) if self.subKind is None and m.get(Vocabulary.KIND) != Vocabulary.ImportWorkflowTask_CLASS: @@ -6407,11 +6006,12 @@ def fromJson(self, m): @classmethod def createFromJson(cls, m): + import tercen.model.impl as impl kind = m.get(Vocabulary.KIND) if kind == Vocabulary.ImportWorkflowTask_CLASS: - return ImportWorkflowTask(m) + return impl.ImportWorkflowTask(m) if kind == Vocabulary.ImportGitWorkflowTask_CLASS: - return ImportGitWorkflowTask(m) + return impl.ImportGitWorkflowTask(m) raise ValueError("bad kind : " + kind + " for class ImportWorkflowTask in createFromJson") @@ -6428,16 +6028,10 @@ def toJson(self): return m -class ImportWorkflowTask(ImportWorkflowTaskBase): - def __init__(self, m=None): - super().__init__(m) - - -class ProjectBase(Document): +class ProjectBase: def __init__(self, m=None): import tercen.model.impl as impl - if ("Document", impl.Document) in inspect.getmembers(impl): - ProjectBase.__bases__ = (impl.Document,) + ProjectBase.__bases__ = (impl.Document,) if m is not None: self.fromJson(m) @@ -6445,6 +6039,7 @@ def __init__(self, m=None): super().__init__(m) def fromJson(self, m): + import tercen.model.impl as impl super().fromJson(m) self.subKind = m.get(Vocabulary.SUBKIND) if self.subKind is None and m.get(Vocabulary.KIND) != Vocabulary.Project_CLASS: @@ -6452,9 +6047,10 @@ def fromJson(self, m): @classmethod def createFromJson(cls, m): + import tercen.model.impl as impl kind = m.get(Vocabulary.KIND) if kind == Vocabulary.Project_CLASS: - return Project(m) + return impl.Project(m) raise ValueError("bad kind : " + kind + " for class Project in createFromJson") @@ -6468,16 +6064,10 @@ def toJson(self): return m -class Project(ProjectBase): - def __init__(self, m=None): - super().__init__(m) - - -class UrlBase(SciObject): +class UrlBase: def __init__(self, m=None): import tercen.model.impl as impl - if ("SciObject", impl.SciObject) in inspect.getmembers(impl): - UrlBase.__bases__ = (impl.SciObject,) + UrlBase.__bases__ = (impl.SciObject,) if m is None: super().__init__(m) self.uri = "" @@ -6485,6 +6075,7 @@ def __init__(self, m=None): self.fromJson(m) def fromJson(self, m): + import tercen.model.impl as impl super().fromJson(m) self.subKind = m.get(Vocabulary.SUBKIND) if self.subKind is None and m.get(Vocabulary.KIND) != Vocabulary.Url_CLASS: @@ -6493,9 +6084,10 @@ def fromJson(self, m): @classmethod def createFromJson(cls, m): + import tercen.model.impl as impl kind = m.get(Vocabulary.KIND) if kind == Vocabulary.Url_CLASS: - return Url(m) + return impl.Url(m) raise ValueError("bad kind : " + kind + " for class Url in createFromJson") @@ -6510,16 +6102,10 @@ def toJson(self): return m -class Url(UrlBase): - def __init__(self, m=None): - super().__init__(m) - - -class StringColorElementBase(ColorElement): +class StringColorElementBase: def __init__(self, m=None): import tercen.model.impl as impl - if ("ColorElement", impl.ColorElement) in inspect.getmembers(impl): - StringColorElementBase.__bases__ = (impl.ColorElement,) + StringColorElementBase.__bases__ = (impl.ColorElement,) if m is None: super().__init__(m) self.stringValue = "" @@ -6527,6 +6113,7 @@ def __init__(self, m=None): self.fromJson(m) def fromJson(self, m): + import tercen.model.impl as impl super().fromJson(m) self.subKind = m.get(Vocabulary.SUBKIND) if self.subKind is None and m.get(Vocabulary.KIND) != Vocabulary.StringColorElement_CLASS: @@ -6535,9 +6122,10 @@ def fromJson(self, m): @classmethod def createFromJson(cls, m): + import tercen.model.impl as impl kind = m.get(Vocabulary.KIND) if kind == Vocabulary.StringColorElement_CLASS: - return StringColorElement(m) + return impl.StringColorElement(m) raise ValueError("bad kind : " + kind + " for class StringColorElement in createFromJson") @@ -6552,16 +6140,10 @@ def toJson(self): return m -class StringColorElement(StringColorElementBase): - def __init__(self, m=None): - super().__init__(m) - - -class EnumeratedPropertyBase(StringProperty): +class EnumeratedPropertyBase: def __init__(self, m=None): import tercen.model.impl as impl - if ("StringProperty", impl.StringProperty) in inspect.getmembers(impl): - EnumeratedPropertyBase.__bases__ = (impl.StringProperty,) + EnumeratedPropertyBase.__bases__ = (impl.StringProperty,) if m is None: super().__init__(m) self.values = list() @@ -6569,6 +6151,7 @@ def __init__(self, m=None): self.fromJson(m) def fromJson(self, m): + import tercen.model.impl as impl super().fromJson(m) self.subKind = m.get(Vocabulary.SUBKIND) if self.subKind is None and m.get(Vocabulary.KIND) != Vocabulary.EnumeratedProperty_CLASS: @@ -6580,9 +6163,10 @@ def fromJson(self, m): @classmethod def createFromJson(cls, m): + import tercen.model.impl as impl kind = m.get(Vocabulary.KIND) if kind == Vocabulary.EnumeratedProperty_CLASS: - return EnumeratedProperty(m) + return impl.EnumeratedProperty(m) raise ValueError("bad kind : " + kind + " for class EnumeratedProperty in createFromJson") @@ -6597,16 +6181,10 @@ def toJson(self): return m -class EnumeratedProperty(EnumeratedPropertyBase): - def __init__(self, m=None): - super().__init__(m) - - -class TestOperatorTaskBase(ProjectTask): +class TestOperatorTaskBase: def __init__(self, m=None): import tercen.model.impl as impl - if ("ProjectTask", impl.ProjectTask) in inspect.getmembers(impl): - TestOperatorTaskBase.__bases__ = (impl.ProjectTask,) + TestOperatorTaskBase.__bases__ = (impl.ProjectTask,) if m is None: super().__init__(m) self.operatorId = "" @@ -6615,6 +6193,7 @@ def __init__(self, m=None): self.fromJson(m) def fromJson(self, m): + import tercen.model.impl as impl super().fromJson(m) self.subKind = m.get(Vocabulary.SUBKIND) if self.subKind is None and m.get(Vocabulary.KIND) != Vocabulary.TestOperatorTask_CLASS: @@ -6624,9 +6203,10 @@ def fromJson(self, m): @classmethod def createFromJson(cls, m): + import tercen.model.impl as impl kind = m.get(Vocabulary.KIND) if kind == Vocabulary.TestOperatorTask_CLASS: - return TestOperatorTask(m) + return impl.TestOperatorTask(m) raise ValueError("bad kind : " + kind + " for class TestOperatorTask in createFromJson") @@ -6642,39 +6222,35 @@ def toJson(self): return m -class TestOperatorTask(TestOperatorTaskBase): - def __init__(self, m=None): - super().__init__(m) - - -class ImportGitWorkflowTaskBase(ImportWorkflowTask): +class ImportGitWorkflowTaskBase: def __init__(self, m=None): import tercen.model.impl as impl - if ("ImportWorkflowTask", impl.ImportWorkflowTask) in inspect.getmembers(impl): - ImportGitWorkflowTaskBase.__bases__ = (impl.ImportWorkflowTask,) + ImportGitWorkflowTaskBase.__bases__ = (impl.ImportWorkflowTask,) if m is None: super().__init__(m) self.version = "" - self.url = Url() + self.url = impl.Url() else: self.fromJson(m) def fromJson(self, m): + import tercen.model.impl as impl super().fromJson(m) self.subKind = m.get(Vocabulary.SUBKIND) if self.subKind is None and m.get(Vocabulary.KIND) != Vocabulary.ImportGitWorkflowTask_CLASS: self.subKind = m.get(Vocabulary.KIND) self.version = m[Vocabulary.version_DP] if m.get(Vocabulary.url_OP) is None: - self.url = Url() + self.url = impl.Url() else: self.url = UrlBase.createFromJson(m.get(Vocabulary.url_OP)) @classmethod def createFromJson(cls, m): + import tercen.model.impl as impl kind = m.get(Vocabulary.KIND) if kind == Vocabulary.ImportGitWorkflowTask_CLASS: - return ImportGitWorkflowTask(m) + return impl.ImportGitWorkflowTask(m) raise ValueError("bad kind : " + kind + " for class ImportGitWorkflowTask in createFromJson") @@ -6690,38 +6266,34 @@ def toJson(self): return m -class ImportGitWorkflowTask(ImportGitWorkflowTaskBase): - def __init__(self, m=None): - super().__init__(m) - - -class ReferenceRelationBase(Relation): +class ReferenceRelationBase: def __init__(self, m=None): import tercen.model.impl as impl - if ("Relation", impl.Relation) in inspect.getmembers(impl): - ReferenceRelationBase.__bases__ = (impl.Relation,) + ReferenceRelationBase.__bases__ = (impl.Relation,) if m is None: super().__init__(m) - self.relation = Relation() + self.relation = impl.Relation() else: self.fromJson(m) def fromJson(self, m): + import tercen.model.impl as impl super().fromJson(m) self.subKind = m.get(Vocabulary.SUBKIND) if self.subKind is None and m.get(Vocabulary.KIND) != Vocabulary.ReferenceRelation_CLASS: self.subKind = m.get(Vocabulary.KIND) if m.get(Vocabulary.relation_OP) is None: - self.relation = Relation() + self.relation = impl.Relation() else: self.relation = RelationBase.createFromJson( m.get(Vocabulary.relation_OP)) @classmethod def createFromJson(cls, m): + import tercen.model.impl as impl kind = m.get(Vocabulary.KIND) if kind == Vocabulary.ReferenceRelation_CLASS: - return ReferenceRelation(m) + return impl.ReferenceRelation(m) raise ValueError("bad kind : " + kind + " for class ReferenceRelation in createFromJson") @@ -6736,16 +6308,10 @@ def toJson(self): return m -class ReferenceRelation(ReferenceRelationBase): - def __init__(self, m=None): - super().__init__(m) - - -class RProxyBase(SciObject): +class RProxyBase: def __init__(self, m=None): import tercen.model.impl as impl - if ("SciObject", impl.SciObject) in inspect.getmembers(impl): - RProxyBase.__bases__ = (impl.SciObject,) + RProxyBase.__bases__ = (impl.SciObject,) if m is None: super().__init__(m) self.name = "" @@ -6754,6 +6320,7 @@ def __init__(self, m=None): self.fromJson(m) def fromJson(self, m): + import tercen.model.impl as impl super().fromJson(m) self.subKind = m.get(Vocabulary.SUBKIND) if self.subKind is None and m.get(Vocabulary.KIND) != Vocabulary.RProxy_CLASS: @@ -6763,9 +6330,10 @@ def fromJson(self, m): @classmethod def createFromJson(cls, m): + import tercen.model.impl as impl kind = m.get(Vocabulary.KIND) if kind == Vocabulary.RProxy_CLASS: - return RProxy(m) + return impl.RProxy(m) raise ValueError("bad kind : " + kind + " for class RProxy in createFromJson") @@ -6781,16 +6349,10 @@ def toJson(self): return m -class RProxy(RProxyBase): - def __init__(self, m=None): - super().__init__(m) - - -class PairBase(SciObject): +class PairBase: def __init__(self, m=None): import tercen.model.impl as impl - if ("SciObject", impl.SciObject) in inspect.getmembers(impl): - PairBase.__bases__ = (impl.SciObject,) + PairBase.__bases__ = (impl.SciObject,) if m is None: super().__init__(m) self.key = "" @@ -6799,6 +6361,7 @@ def __init__(self, m=None): self.fromJson(m) def fromJson(self, m): + import tercen.model.impl as impl super().fromJson(m) self.subKind = m.get(Vocabulary.SUBKIND) if self.subKind is None and m.get(Vocabulary.KIND) != Vocabulary.Pair_CLASS: @@ -6808,9 +6371,10 @@ def fromJson(self, m): @classmethod def createFromJson(cls, m): + import tercen.model.impl as impl kind = m.get(Vocabulary.KIND) if kind == Vocabulary.Pair_CLASS: - return Pair(m) + return impl.Pair(m) raise ValueError("bad kind : " + kind + " for class Pair in createFromJson") @@ -6826,38 +6390,34 @@ def toJson(self): return m -class Pair(PairBase): - def __init__(self, m=None): - super().__init__(m) - - -class InMemoryRelationBase(Relation): +class InMemoryRelationBase: def __init__(self, m=None): import tercen.model.impl as impl - if ("Relation", impl.Relation) in inspect.getmembers(impl): - InMemoryRelationBase.__bases__ = (impl.Relation,) + InMemoryRelationBase.__bases__ = (impl.Relation,) if m is None: super().__init__(m) - self.inMemoryTable = Table() + self.inMemoryTable = impl.Table() else: self.fromJson(m) def fromJson(self, m): + import tercen.model.impl as impl super().fromJson(m) self.subKind = m.get(Vocabulary.SUBKIND) if self.subKind is None and m.get(Vocabulary.KIND) != Vocabulary.InMemoryRelation_CLASS: self.subKind = m.get(Vocabulary.KIND) if m.get(Vocabulary.inMemoryTable_OP) is None: - self.inMemoryTable = Table() + self.inMemoryTable = impl.Table() else: self.inMemoryTable = TableBase.createFromJson( m.get(Vocabulary.inMemoryTable_OP)) @classmethod def createFromJson(cls, m): + import tercen.model.impl as impl kind = m.get(Vocabulary.KIND) if kind == Vocabulary.InMemoryRelation_CLASS: - return InMemoryRelation(m) + return impl.InMemoryRelation(m) raise ValueError("bad kind : " + kind + " for class InMemoryRelation in createFromJson") @@ -6872,16 +6432,10 @@ def toJson(self): return m -class InMemoryRelation(InMemoryRelationBase): - def __init__(self, m=None): - super().__init__(m) - - -class RunProfileBase(Profile): +class RunProfileBase: def __init__(self, m=None): import tercen.model.impl as impl - if ("Profile", impl.Profile) in inspect.getmembers(impl): - RunProfileBase.__bases__ = (impl.Profile,) + RunProfileBase.__bases__ = (impl.Profile,) if m is None: super().__init__(m) self.memory = 0 @@ -6896,6 +6450,7 @@ def __init__(self, m=None): self.fromJson(m) def fromJson(self, m): + import tercen.model.impl as impl super().fromJson(m) self.subKind = m.get(Vocabulary.SUBKIND) if self.subKind is None and m.get(Vocabulary.KIND) != Vocabulary.RunProfile_CLASS: @@ -6911,9 +6466,10 @@ def fromJson(self, m): @classmethod def createFromJson(cls, m): + import tercen.model.impl as impl kind = m.get(Vocabulary.KIND) if kind == Vocabulary.RunProfile_CLASS: - return RunProfile(m) + return impl.RunProfile(m) raise ValueError("bad kind : " + kind + " for class RunProfile in createFromJson") @@ -6935,16 +6491,10 @@ def toJson(self): return m -class RunProfile(RunProfileBase): - def __init__(self, m=None): - super().__init__(m) - - -class CpuTimeProfileBase(Profile): +class CpuTimeProfileBase: def __init__(self, m=None): import tercen.model.impl as impl - if ("Profile", impl.Profile) in inspect.getmembers(impl): - CpuTimeProfileBase.__bases__ = (impl.Profile,) + CpuTimeProfileBase.__bases__ = (impl.Profile,) if m is None: super().__init__(m) self.cpuTime = 0.0 @@ -6952,6 +6502,7 @@ def __init__(self, m=None): self.fromJson(m) def fromJson(self, m): + import tercen.model.impl as impl super().fromJson(m) self.subKind = m.get(Vocabulary.SUBKIND) if self.subKind is None and m.get(Vocabulary.KIND) != Vocabulary.CpuTimeProfile_CLASS: @@ -6960,9 +6511,10 @@ def fromJson(self, m): @classmethod def createFromJson(cls, m): + import tercen.model.impl as impl kind = m.get(Vocabulary.KIND) if kind == Vocabulary.CpuTimeProfile_CLASS: - return CpuTimeProfile(m) + return impl.CpuTimeProfile(m) raise ValueError("bad kind : " + kind + " for class CpuTimeProfile in createFromJson") @@ -6977,13 +6529,9 @@ def toJson(self): return m -class CpuTimeProfile(CpuTimeProfileBase): - def __init__(self, m=None): - super().__init__(m) - - -class AxisSettingsBase(BaseObject): +class AxisSettingsBase: def __init__(self, m=None): + import tercen.model.impl as impl if m is None: super().__init__(m) self.meta = list() @@ -6991,6 +6539,7 @@ def __init__(self, m=None): self.fromJson(m) def fromJson(self, m): + import tercen.model.impl as impl super().fromJson(m) self.subKind = m.get(Vocabulary.SUBKIND) if self.subKind is None and m.get(Vocabulary.KIND) != Vocabulary.AxisSettings_CLASS: @@ -7004,9 +6553,10 @@ def fromJson(self, m): @classmethod def createFromJson(cls, m): + import tercen.model.impl as impl kind = m.get(Vocabulary.KIND) if kind == Vocabulary.AxisSettings_CLASS: - return AxisSettings(m) + return impl.AxisSettings(m) raise ValueError("bad kind : " + kind + " for class AxisSettings in createFromJson") @@ -7021,23 +6571,20 @@ def toJson(self): return m -class AxisSettings(AxisSettingsBase): - def __init__(self, m=None): - super().__init__(m) - - -class MappingFilterBase(BaseObject): +class MappingFilterBase: def __init__(self, m=None): + import tercen.model.impl as impl if m is None: super().__init__(m) self.name = "" self.description = "" self.isRequired = True - self.namedFilter = NamedFilter() + self.namedFilter = impl.NamedFilter() else: self.fromJson(m) def fromJson(self, m): + import tercen.model.impl as impl super().fromJson(m) self.subKind = m.get(Vocabulary.SUBKIND) if self.subKind is None and m.get(Vocabulary.KIND) != Vocabulary.MappingFilter_CLASS: @@ -7046,16 +6593,17 @@ def fromJson(self, m): self.description = m[Vocabulary.description_DP] self.isRequired = m[Vocabulary.isRequired_DP] if m.get(Vocabulary.namedFilter_OP) is None: - self.namedFilter = NamedFilter() + self.namedFilter = impl.NamedFilter() else: self.namedFilter = NamedFilterBase.createFromJson( m.get(Vocabulary.namedFilter_OP)) @classmethod def createFromJson(cls, m): + import tercen.model.impl as impl kind = m.get(Vocabulary.KIND) if kind == Vocabulary.MappingFilter_CLASS: - return MappingFilter(m) + return impl.MappingFilter(m) raise ValueError("bad kind : " + kind + " for class MappingFilter in createFromJson") @@ -7073,16 +6621,10 @@ def toJson(self): return m -class MappingFilter(MappingFilterBase): - def __init__(self, m=None): - super().__init__(m) - - -class ChartBarBase(Chart): +class ChartBarBase: def __init__(self, m=None): import tercen.model.impl as impl - if ("Chart", impl.Chart) in inspect.getmembers(impl): - ChartBarBase.__bases__ = (impl.Chart,) + ChartBarBase.__bases__ = (impl.Chart,) if m is not None: self.fromJson(m) @@ -7090,6 +6632,7 @@ def __init__(self, m=None): super().__init__(m) def fromJson(self, m): + import tercen.model.impl as impl super().fromJson(m) self.subKind = m.get(Vocabulary.SUBKIND) if self.subKind is None and m.get(Vocabulary.KIND) != Vocabulary.ChartBar_CLASS: @@ -7097,9 +6640,10 @@ def fromJson(self, m): @classmethod def createFromJson(cls, m): + import tercen.model.impl as impl kind = m.get(Vocabulary.KIND) if kind == Vocabulary.ChartBar_CLASS: - return ChartBar(m) + return impl.ChartBar(m) raise ValueError("bad kind : " + kind + " for class ChartBar in createFromJson") @@ -7113,16 +6657,10 @@ def toJson(self): return m -class ChartBar(ChartBarBase): - def __init__(self, m=None): - super().__init__(m) - - -class FolderDocumentBase(ProjectDocument): +class FolderDocumentBase: def __init__(self, m=None): import tercen.model.impl as impl - if ("ProjectDocument", impl.ProjectDocument) in inspect.getmembers(impl): - FolderDocumentBase.__bases__ = (impl.ProjectDocument,) + FolderDocumentBase.__bases__ = (impl.ProjectDocument,) if m is not None: self.fromJson(m) @@ -7130,6 +6668,7 @@ def __init__(self, m=None): super().__init__(m) def fromJson(self, m): + import tercen.model.impl as impl super().fromJson(m) self.subKind = m.get(Vocabulary.SUBKIND) if self.subKind is None and m.get(Vocabulary.KIND) != Vocabulary.FolderDocument_CLASS: @@ -7137,9 +6676,10 @@ def fromJson(self, m): @classmethod def createFromJson(cls, m): + import tercen.model.impl as impl kind = m.get(Vocabulary.KIND) if kind == Vocabulary.FolderDocument_CLASS: - return FolderDocument(m) + return impl.FolderDocument(m) raise ValueError("bad kind : " + kind + " for class FolderDocument in createFromJson") @@ -7153,16 +6693,10 @@ def toJson(self): return m -class FolderDocument(FolderDocumentBase): - def __init__(self, m=None): - super().__init__(m) - - -class LockBase(PersistentObject): +class LockBase: def __init__(self, m=None): import tercen.model.impl as impl - if ("PersistentObject", impl.PersistentObject) in inspect.getmembers(impl): - LockBase.__bases__ = (impl.PersistentObject,) + LockBase.__bases__ = (impl.PersistentObject,) if m is None: super().__init__(m) self.name = "" @@ -7170,6 +6704,7 @@ def __init__(self, m=None): self.fromJson(m) def fromJson(self, m): + import tercen.model.impl as impl super().fromJson(m) self.subKind = m.get(Vocabulary.SUBKIND) if self.subKind is None and m.get(Vocabulary.KIND) != Vocabulary.Lock_CLASS: @@ -7178,9 +6713,10 @@ def fromJson(self, m): @classmethod def createFromJson(cls, m): + import tercen.model.impl as impl kind = m.get(Vocabulary.KIND) if kind == Vocabulary.Lock_CLASS: - return Lock(m) + return impl.Lock(m) raise ValueError("bad kind : " + kind + " for class Lock in createFromJson") @@ -7195,16 +6731,10 @@ def toJson(self): return m -class Lock(LockBase): - def __init__(self, m=None): - super().__init__(m) - - -class WorkerBase(SciObject): +class WorkerBase: def __init__(self, m=None): import tercen.model.impl as impl - if ("SciObject", impl.SciObject) in inspect.getmembers(impl): - WorkerBase.__bases__ = (impl.SciObject,) + WorkerBase.__bases__ = (impl.SciObject,) if m is None: super().__init__(m) self.status = "" @@ -7224,6 +6754,7 @@ def __init__(self, m=None): self.fromJson(m) def fromJson(self, m): + import tercen.model.impl as impl super().fromJson(m) self.subKind = m.get(Vocabulary.SUBKIND) if self.subKind is None and m.get(Vocabulary.KIND) != Vocabulary.Worker_CLASS: @@ -7250,9 +6781,10 @@ def fromJson(self, m): @classmethod def createFromJson(cls, m): + import tercen.model.impl as impl kind = m.get(Vocabulary.KIND) if kind == Vocabulary.Worker_CLASS: - return Worker(m) + return impl.Worker(m) raise ValueError("bad kind : " + kind + " for class Worker in createFromJson") @@ -7279,26 +6811,21 @@ def toJson(self): return m -class Worker(WorkerBase): - def __init__(self, m=None): - super().__init__(m) - - -class ImportGitDatasetTaskBase(ProjectTask): +class ImportGitDatasetTaskBase: def __init__(self, m=None): import tercen.model.impl as impl - if ("ProjectTask", impl.ProjectTask) in inspect.getmembers(impl): - ImportGitDatasetTaskBase.__bases__ = (impl.ProjectTask,) + ImportGitDatasetTaskBase.__bases__ = (impl.ProjectTask,) if m is None: super().__init__(m) self.version = "" self.gitToken = "" self.schemaId = "" - self.url = Url() + self.url = impl.Url() else: self.fromJson(m) def fromJson(self, m): + import tercen.model.impl as impl super().fromJson(m) self.subKind = m.get(Vocabulary.SUBKIND) if self.subKind is None and m.get(Vocabulary.KIND) != Vocabulary.ImportGitDatasetTask_CLASS: @@ -7307,15 +6834,16 @@ def fromJson(self, m): self.gitToken = m[Vocabulary.gitToken_DP] self.schemaId = m[Vocabulary.schemaId_DP] if m.get(Vocabulary.url_OP) is None: - self.url = Url() + self.url = impl.Url() else: self.url = UrlBase.createFromJson(m.get(Vocabulary.url_OP)) @classmethod def createFromJson(cls, m): + import tercen.model.impl as impl kind = m.get(Vocabulary.KIND) if kind == Vocabulary.ImportGitDatasetTask_CLASS: - return ImportGitDatasetTask(m) + return impl.ImportGitDatasetTask(m) raise ValueError("bad kind : " + kind + " for class ImportGitDatasetTask in createFromJson") @@ -7333,16 +6861,10 @@ def toJson(self): return m -class ImportGitDatasetTask(ImportGitDatasetTaskBase): - def __init__(self, m=None): - super().__init__(m) - - -class AceBase(SciObject): +class AceBase: def __init__(self, m=None): import tercen.model.impl as impl - if ("SciObject", impl.SciObject) in inspect.getmembers(impl): - AceBase.__bases__ = (impl.SciObject,) + AceBase.__bases__ = (impl.SciObject,) if m is None: super().__init__(m) self.principals = list() @@ -7351,6 +6873,7 @@ def __init__(self, m=None): self.fromJson(m) def fromJson(self, m): + import tercen.model.impl as impl super().fromJson(m) self.subKind = m.get(Vocabulary.SUBKIND) if self.subKind is None and m.get(Vocabulary.KIND) != Vocabulary.Ace_CLASS: @@ -7370,9 +6893,10 @@ def fromJson(self, m): @classmethod def createFromJson(cls, m): + import tercen.model.impl as impl kind = m.get(Vocabulary.KIND) if kind == Vocabulary.Ace_CLASS: - return Ace(m) + return impl.Ace(m) raise ValueError("bad kind : " + kind + " for class Ace in createFromJson") @@ -7390,38 +6914,34 @@ def toJson(self): return m -class Ace(AceBase): - def __init__(self, m=None): - super().__init__(m) - - -class InStepBase(RelationStep): +class InStepBase: def __init__(self, m=None): import tercen.model.impl as impl - if ("RelationStep", impl.RelationStep) in inspect.getmembers(impl): - InStepBase.__bases__ = (impl.RelationStep,) + InStepBase.__bases__ = (impl.RelationStep,) if m is None: super().__init__(m) - self.groupPortPosition = Point() + self.groupPortPosition = impl.Point() else: self.fromJson(m) def fromJson(self, m): + import tercen.model.impl as impl super().fromJson(m) self.subKind = m.get(Vocabulary.SUBKIND) if self.subKind is None and m.get(Vocabulary.KIND) != Vocabulary.InStep_CLASS: self.subKind = m.get(Vocabulary.KIND) if m.get(Vocabulary.groupPortPosition_OP) is None: - self.groupPortPosition = Point() + self.groupPortPosition = impl.Point() else: self.groupPortPosition = PointBase.createFromJson( m.get(Vocabulary.groupPortPosition_OP)) @classmethod def createFromJson(cls, m): + import tercen.model.impl as impl kind = m.get(Vocabulary.KIND) if kind == Vocabulary.InStep_CLASS: - return InStep(m) + return impl.InStep(m) raise ValueError("bad kind : " + kind + " for class InStep in createFromJson") @@ -7436,16 +6956,10 @@ def toJson(self): return m -class InStep(InStepBase): - def __init__(self, m=None): - super().__init__(m) - - -class LabelsBase(SciObject): +class LabelsBase: def __init__(self, m=None): import tercen.model.impl as impl - if ("SciObject", impl.SciObject) in inspect.getmembers(impl): - LabelsBase.__bases__ = (impl.SciObject,) + LabelsBase.__bases__ = (impl.SciObject,) if m is None: super().__init__(m) self.factors = list() @@ -7453,6 +6967,7 @@ def __init__(self, m=None): self.fromJson(m) def fromJson(self, m): + import tercen.model.impl as impl super().fromJson(m) self.subKind = m.get(Vocabulary.SUBKIND) if self.subKind is None and m.get(Vocabulary.KIND) != Vocabulary.Labels_CLASS: @@ -7466,9 +6981,10 @@ def fromJson(self, m): @classmethod def createFromJson(cls, m): + import tercen.model.impl as impl kind = m.get(Vocabulary.KIND) if kind == Vocabulary.Labels_CLASS: - return Labels(m) + return impl.Labels(m) raise ValueError("bad kind : " + kind + " for class Labels in createFromJson") @@ -7484,16 +7000,10 @@ def toJson(self): return m -class Labels(LabelsBase): - def __init__(self, m=None): - super().__init__(m) - - -class RenvInstalledLibraryBase(RLibrary): +class RenvInstalledLibraryBase: def __init__(self, m=None): import tercen.model.impl as impl - if ("RLibrary", impl.RLibrary) in inspect.getmembers(impl): - RenvInstalledLibraryBase.__bases__ = (impl.RLibrary,) + RenvInstalledLibraryBase.__bases__ = (impl.RLibrary,) if m is None: super().__init__(m) self.path = "" @@ -7501,6 +7011,7 @@ def __init__(self, m=None): self.fromJson(m) def fromJson(self, m): + import tercen.model.impl as impl super().fromJson(m) self.subKind = m.get(Vocabulary.SUBKIND) if self.subKind is None and m.get(Vocabulary.KIND) != Vocabulary.RenvInstalledLibrary_CLASS: @@ -7509,9 +7020,10 @@ def fromJson(self, m): @classmethod def createFromJson(cls, m): + import tercen.model.impl as impl kind = m.get(Vocabulary.KIND) if kind == Vocabulary.RenvInstalledLibrary_CLASS: - return RenvInstalledLibrary(m) + return impl.RenvInstalledLibrary(m) raise ValueError("bad kind : " + kind + " for class RenvInstalledLibrary in createFromJson") @@ -7526,33 +7038,28 @@ def toJson(self): return m -class RenvInstalledLibrary(RenvInstalledLibraryBase): - def __init__(self, m=None): - super().__init__(m) - - -class OperatorSettingsBase(SciObject): +class OperatorSettingsBase: def __init__(self, m=None): import tercen.model.impl as impl - if ("SciObject", impl.SciObject) in inspect.getmembers(impl): - OperatorSettingsBase.__bases__ = (impl.SciObject,) + OperatorSettingsBase.__bases__ = (impl.SciObject,) if m is None: super().__init__(m) self.namespace = "" - self.operatorRef = OperatorRef() + self.operatorRef = impl.OperatorRef() self.environment = list() - self.operatorModel = OperatorModel() + self.operatorModel = impl.OperatorModel() else: self.fromJson(m) def fromJson(self, m): + import tercen.model.impl as impl super().fromJson(m) self.subKind = m.get(Vocabulary.SUBKIND) if self.subKind is None and m.get(Vocabulary.KIND) != Vocabulary.OperatorSettings_CLASS: self.subKind = m.get(Vocabulary.KIND) self.namespace = m[Vocabulary.namespace_DP] if m.get(Vocabulary.operatorRef_OP) is None: - self.operatorRef = OperatorRef() + self.operatorRef = impl.OperatorRef() else: self.operatorRef = OperatorRefBase.createFromJson( m.get(Vocabulary.operatorRef_OP)) @@ -7563,16 +7070,17 @@ def fromJson(self, m): for o in m.get(Vocabulary.environment_OP): self.environment.append(PairBase.createFromJson(o)) if m.get(Vocabulary.operatorModel_OP) is None: - self.operatorModel = OperatorModel() + self.operatorModel = impl.OperatorModel() else: self.operatorModel = OperatorModelBase.createFromJson( m.get(Vocabulary.operatorModel_OP)) @classmethod def createFromJson(cls, m): + import tercen.model.impl as impl kind = m.get(Vocabulary.KIND) if kind == Vocabulary.OperatorSettings_CLASS: - return OperatorSettings(m) + return impl.OperatorSettings(m) raise ValueError("bad kind : " + kind + " for class OperatorSettings in createFromJson") @@ -7591,26 +7099,21 @@ def toJson(self): return m -class OperatorSettings(OperatorSettingsBase): - def __init__(self, m=None): - super().__init__(m) - - -class SchemaBase(ProjectDocument): +class SchemaBase: def __init__(self, m=None): import tercen.model.impl as impl - if ("ProjectDocument", impl.ProjectDocument) in inspect.getmembers(impl): - SchemaBase.__bases__ = (impl.ProjectDocument,) + SchemaBase.__bases__ = (impl.ProjectDocument,) if m is None: super().__init__(m) self.nRows = 0 self.dataDirectory = "" self.columns = list() - self.relation = Relation() + self.relation = impl.Relation() else: self.fromJson(m) def fromJson(self, m): + import tercen.model.impl as impl super().fromJson(m) self.subKind = m.get(Vocabulary.SUBKIND) if self.subKind is None and m.get(Vocabulary.KIND) != Vocabulary.Schema_CLASS: @@ -7624,22 +7127,23 @@ def fromJson(self, m): for o in m.get(Vocabulary.columns_OP): self.columns.append(ColumnSchemaBase.createFromJson(o)) if m.get(Vocabulary.relation_OP) is None: - self.relation = Relation() + self.relation = impl.Relation() else: self.relation = RelationBase.createFromJson( m.get(Vocabulary.relation_OP)) @classmethod def createFromJson(cls, m): + import tercen.model.impl as impl kind = m.get(Vocabulary.KIND) if kind == Vocabulary.Schema_CLASS: - return Schema(m) + return impl.Schema(m) if kind == Vocabulary.CubeQueryTableSchema_CLASS: - return CubeQueryTableSchema(m) + return impl.CubeQueryTableSchema(m) if kind == Vocabulary.TableSchema_CLASS: - return TableSchema(m) + return impl.TableSchema(m) if kind == Vocabulary.ComputedTableSchema_CLASS: - return ComputedTableSchema(m) + return impl.ComputedTableSchema(m) raise ValueError("bad kind : " + kind + " for class Schema in createFromJson") @@ -7658,25 +7162,20 @@ def toJson(self): return m -class Schema(SchemaBase): - def __init__(self, m=None): - super().__init__(m) - - -class CubeQueryTableSchemaBase(Schema): +class CubeQueryTableSchemaBase: def __init__(self, m=None): import tercen.model.impl as impl - if ("Schema", impl.Schema) in inspect.getmembers(impl): - CubeQueryTableSchemaBase.__bases__ = (impl.Schema,) + CubeQueryTableSchemaBase.__bases__ = (impl.Schema,) if m is None: super().__init__(m) self.queryHash = "" self.queryTableType = "" - self.query = CubeQuery() + self.query = impl.CubeQuery() else: self.fromJson(m) def fromJson(self, m): + import tercen.model.impl as impl super().fromJson(m) self.subKind = m.get(Vocabulary.SUBKIND) if self.subKind is None and m.get(Vocabulary.KIND) != Vocabulary.CubeQueryTableSchema_CLASS: @@ -7684,16 +7183,17 @@ def fromJson(self, m): self.queryHash = m[Vocabulary.queryHash_DP] self.queryTableType = m[Vocabulary.queryTableType_DP] if m.get(Vocabulary.query_OP) is None: - self.query = CubeQuery() + self.query = impl.CubeQuery() else: self.query = CubeQueryBase.createFromJson( m.get(Vocabulary.query_OP)) @classmethod def createFromJson(cls, m): + import tercen.model.impl as impl kind = m.get(Vocabulary.KIND) if kind == Vocabulary.CubeQueryTableSchema_CLASS: - return CubeQueryTableSchema(m) + return impl.CubeQueryTableSchema(m) raise ValueError("bad kind : " + kind + " for class CubeQueryTableSchema in createFromJson") @@ -7710,30 +7210,25 @@ def toJson(self): return m -class CubeQueryTableSchema(CubeQueryTableSchemaBase): - def __init__(self, m=None): - super().__init__(m) - - -class CategoryPaletteBase(Palette): +class CategoryPaletteBase: def __init__(self, m=None): import tercen.model.impl as impl - if ("Palette", impl.Palette) in inspect.getmembers(impl): - CategoryPaletteBase.__bases__ = (impl.Palette,) + CategoryPaletteBase.__bases__ = (impl.Palette,) if m is None: super().__init__(m) - self.colorList = ColorList() + self.colorList = impl.ColorList() self.stringColorElements = list() else: self.fromJson(m) def fromJson(self, m): + import tercen.model.impl as impl super().fromJson(m) self.subKind = m.get(Vocabulary.SUBKIND) if self.subKind is None and m.get(Vocabulary.KIND) != Vocabulary.CategoryPalette_CLASS: self.subKind = m.get(Vocabulary.KIND) if m.get(Vocabulary.colorList_OP) is None: - self.colorList = ColorList() + self.colorList = impl.ColorList() else: self.colorList = ColorListBase.createFromJson( m.get(Vocabulary.colorList_OP)) @@ -7747,9 +7242,10 @@ def fromJson(self, m): @classmethod def createFromJson(cls, m): + import tercen.model.impl as impl kind = m.get(Vocabulary.KIND) if kind == Vocabulary.CategoryPalette_CLASS: - return CategoryPalette(m) + return impl.CategoryPalette(m) raise ValueError("bad kind : " + kind + " for class CategoryPalette in createFromJson") @@ -7766,16 +7262,10 @@ def toJson(self): return m -class CategoryPalette(CategoryPaletteBase): - def __init__(self, m=None): - super().__init__(m) - - -class TableSummaryBase(SciObject): +class TableSummaryBase: def __init__(self, m=None): import tercen.model.impl as impl - if ("SciObject", impl.SciObject) in inspect.getmembers(impl): - TableSummaryBase.__bases__ = (impl.SciObject,) + TableSummaryBase.__bases__ = (impl.SciObject,) if m is None: super().__init__(m) self.n = 0 @@ -7786,6 +7276,7 @@ def __init__(self, m=None): self.fromJson(m) def fromJson(self, m): + import tercen.model.impl as impl super().fromJson(m) self.subKind = m.get(Vocabulary.SUBKIND) if self.subKind is None and m.get(Vocabulary.KIND) != Vocabulary.TableSummary_CLASS: @@ -7797,9 +7288,10 @@ def fromJson(self, m): @classmethod def createFromJson(cls, m): + import tercen.model.impl as impl kind = m.get(Vocabulary.KIND) if kind == Vocabulary.TableSummary_CLASS: - return TableSummary(m) + return impl.TableSummary(m) raise ValueError("bad kind : " + kind + " for class TableSummary in createFromJson") @@ -7817,16 +7309,10 @@ def toJson(self): return m -class TableSummary(TableSummaryBase): - def __init__(self, m=None): - super().__init__(m) - - -class PointBase(SciObject): +class PointBase: def __init__(self, m=None): import tercen.model.impl as impl - if ("SciObject", impl.SciObject) in inspect.getmembers(impl): - PointBase.__bases__ = (impl.SciObject,) + PointBase.__bases__ = (impl.SciObject,) if m is None: super().__init__(m) self.x = 0.0 @@ -7835,6 +7321,7 @@ def __init__(self, m=None): self.fromJson(m) def fromJson(self, m): + import tercen.model.impl as impl super().fromJson(m) self.subKind = m.get(Vocabulary.SUBKIND) if self.subKind is None and m.get(Vocabulary.KIND) != Vocabulary.Point_CLASS: @@ -7844,9 +7331,10 @@ def fromJson(self, m): @classmethod def createFromJson(cls, m): + import tercen.model.impl as impl kind = m.get(Vocabulary.KIND) if kind == Vocabulary.Point_CLASS: - return Point(m) + return impl.Point(m) raise ValueError("bad kind : " + kind + " for class Point in createFromJson") @@ -7862,27 +7350,22 @@ def toJson(self): return m -class Point(PointBase): - def __init__(self, m=None): - super().__init__(m) - - -class ColumnSchemaBase(IdObject): +class ColumnSchemaBase: def __init__(self, m=None): import tercen.model.impl as impl - if ("IdObject", impl.IdObject) in inspect.getmembers(impl): - ColumnSchemaBase.__bases__ = (impl.IdObject,) + ColumnSchemaBase.__bases__ = (impl.IdObject,) if m is None: super().__init__(m) self.name = "" self.type = "" self.nRows = 0 self.size = 0 - self.metaData = ColumnSchemaMetaData() + self.metaData = impl.ColumnSchemaMetaData() else: self.fromJson(m) def fromJson(self, m): + import tercen.model.impl as impl super().fromJson(m) self.subKind = m.get(Vocabulary.SUBKIND) if self.subKind is None and m.get(Vocabulary.KIND) != Vocabulary.ColumnSchema_CLASS: @@ -7892,18 +7375,19 @@ def fromJson(self, m): self.nRows = m[Vocabulary.nRows_DP] self.size = m[Vocabulary.size_DP] if m.get(Vocabulary.metaData_OP) is None: - self.metaData = ColumnSchemaMetaData() + self.metaData = impl.ColumnSchemaMetaData() else: self.metaData = ColumnSchemaMetaDataBase.createFromJson( m.get(Vocabulary.metaData_OP)) @classmethod def createFromJson(cls, m): + import tercen.model.impl as impl kind = m.get(Vocabulary.KIND) if kind == Vocabulary.ColumnSchema_CLASS: - return ColumnSchema(m) + return impl.ColumnSchema(m) if kind == Vocabulary.Column_CLASS: - return Column(m) + return impl.Column(m) raise ValueError("bad kind : " + kind + " for class ColumnSchema in createFromJson") @@ -7922,16 +7406,10 @@ def toJson(self): return m -class ColumnSchema(ColumnSchemaBase): - def __init__(self, m=None): - super().__init__(m) - - -class ColumnBase(ColumnSchema): +class ColumnBase: def __init__(self, m=None): import tercen.model.impl as impl - if ("ColumnSchema", impl.ColumnSchema) in inspect.getmembers(impl): - ColumnBase.__bases__ = (impl.ColumnSchema,) + ColumnBase.__bases__ = (impl.ColumnSchema,) if m is None: super().__init__(m) self.values = None @@ -7939,6 +7417,7 @@ def __init__(self, m=None): self.fromJson(m) def fromJson(self, m): + import tercen.model.impl as impl super().fromJson(m) self.subKind = m.get(Vocabulary.SUBKIND) if self.subKind is None and m.get(Vocabulary.KIND) != Vocabulary.Column_CLASS: @@ -7947,9 +7426,10 @@ def fromJson(self, m): @classmethod def createFromJson(cls, m): + import tercen.model.impl as impl kind = m.get(Vocabulary.KIND) if kind == Vocabulary.Column_CLASS: - return Column(m) + return impl.Column(m) raise ValueError("bad kind : " + kind + " for class Column in createFromJson") @@ -7964,56 +7444,52 @@ def toJson(self): return m -class Column(ColumnBase): - def __init__(self, m=None): - super().__init__(m) - - -class SummaryBase(SciObject): +class SummaryBase: def __init__(self, m=None): import tercen.model.impl as impl - if ("SciObject", impl.SciObject) in inspect.getmembers(impl): - SummaryBase.__bases__ = (impl.SciObject,) + SummaryBase.__bases__ = (impl.SciObject,) if m is None: super().__init__(m) - self.tableSummary = TableSummary() - self.computedTableSummary = TableSummary() - self.queryTableSummary = TableSummary() - self.taskSummary = TaskSummary() + self.tableSummary = impl.TableSummary() + self.computedTableSummary = impl.TableSummary() + self.queryTableSummary = impl.TableSummary() + self.taskSummary = impl.TaskSummary() else: self.fromJson(m) def fromJson(self, m): + import tercen.model.impl as impl super().fromJson(m) self.subKind = m.get(Vocabulary.SUBKIND) if self.subKind is None and m.get(Vocabulary.KIND) != Vocabulary.Summary_CLASS: self.subKind = m.get(Vocabulary.KIND) if m.get(Vocabulary.tableSummary_OP) is None: - self.tableSummary = TableSummary() + self.tableSummary = impl.TableSummary() else: self.tableSummary = TableSummaryBase.createFromJson( m.get(Vocabulary.tableSummary_OP)) if m.get(Vocabulary.computedTableSummary_OP) is None: - self.computedTableSummary = TableSummary() + self.computedTableSummary = impl.TableSummary() else: self.computedTableSummary = TableSummaryBase.createFromJson( m.get(Vocabulary.computedTableSummary_OP)) if m.get(Vocabulary.queryTableSummary_OP) is None: - self.queryTableSummary = TableSummary() + self.queryTableSummary = impl.TableSummary() else: self.queryTableSummary = TableSummaryBase.createFromJson( m.get(Vocabulary.queryTableSummary_OP)) if m.get(Vocabulary.taskSummary_OP) is None: - self.taskSummary = TaskSummary() + self.taskSummary = impl.TaskSummary() else: self.taskSummary = TaskSummaryBase.createFromJson( m.get(Vocabulary.taskSummary_OP)) @classmethod def createFromJson(cls, m): + import tercen.model.impl as impl kind = m.get(Vocabulary.KIND) if kind == Vocabulary.Summary_CLASS: - return Summary(m) + return impl.Summary(m) raise ValueError("bad kind : " + kind + " for class Summary in createFromJson") @@ -8031,37 +7507,33 @@ def toJson(self): return m -class Summary(SummaryBase): - def __init__(self, m=None): - super().__init__(m) - - -class TaskStateEventBase(TaskEvent): +class TaskStateEventBase: def __init__(self, m=None): import tercen.model.impl as impl - if ("TaskEvent", impl.TaskEvent) in inspect.getmembers(impl): - TaskStateEventBase.__bases__ = (impl.TaskEvent,) + TaskStateEventBase.__bases__ = (impl.TaskEvent,) if m is None: super().__init__(m) - self.state = State() + self.state = impl.State() else: self.fromJson(m) def fromJson(self, m): + import tercen.model.impl as impl super().fromJson(m) self.subKind = m.get(Vocabulary.SUBKIND) if self.subKind is None and m.get(Vocabulary.KIND) != Vocabulary.TaskStateEvent_CLASS: self.subKind = m.get(Vocabulary.KIND) if m.get(Vocabulary.state_OP) is None: - self.state = State() + self.state = impl.State() else: self.state = StateBase.createFromJson(m.get(Vocabulary.state_OP)) @classmethod def createFromJson(cls, m): + import tercen.model.impl as impl kind = m.get(Vocabulary.KIND) if kind == Vocabulary.TaskStateEvent_CLASS: - return TaskStateEvent(m) + return impl.TaskStateEvent(m) raise ValueError("bad kind : " + kind + " for class TaskStateEvent in createFromJson") @@ -8076,16 +7548,10 @@ def toJson(self): return m -class TaskStateEvent(TaskStateEventBase): - def __init__(self, m=None): - super().__init__(m) - - -class WebAppOperatorBase(GitOperator): +class WebAppOperatorBase: def __init__(self, m=None): import tercen.model.impl as impl - if ("GitOperator", impl.GitOperator) in inspect.getmembers(impl): - WebAppOperatorBase.__bases__ = (impl.GitOperator,) + WebAppOperatorBase.__bases__ = (impl.GitOperator,) if m is None: super().__init__(m) self.isViewOnly = True @@ -8093,6 +7559,7 @@ def __init__(self, m=None): self.fromJson(m) def fromJson(self, m): + import tercen.model.impl as impl super().fromJson(m) self.subKind = m.get(Vocabulary.SUBKIND) if self.subKind is None and m.get(Vocabulary.KIND) != Vocabulary.WebAppOperator_CLASS: @@ -8101,13 +7568,14 @@ def fromJson(self, m): @classmethod def createFromJson(cls, m): + import tercen.model.impl as impl kind = m.get(Vocabulary.KIND) if kind == Vocabulary.WebAppOperator_CLASS: - return WebAppOperator(m) + return impl.WebAppOperator(m) if kind == Vocabulary.ShinyOperator_CLASS: - return ShinyOperator(m) + return impl.ShinyOperator(m) if kind == Vocabulary.DockerWebAppOperator_CLASS: - return DockerWebAppOperator(m) + return impl.DockerWebAppOperator(m) raise ValueError("bad kind : " + kind + " for class WebAppOperator in createFromJson") @@ -8122,16 +7590,10 @@ def toJson(self): return m -class WebAppOperator(WebAppOperatorBase): - def __init__(self, m=None): - super().__init__(m) - - -class ShinyOperatorBase(WebAppOperator): +class ShinyOperatorBase: def __init__(self, m=None): import tercen.model.impl as impl - if ("WebAppOperator", impl.WebAppOperator) in inspect.getmembers(impl): - ShinyOperatorBase.__bases__ = (impl.WebAppOperator,) + ShinyOperatorBase.__bases__ = (impl.WebAppOperator,) if m is not None: self.fromJson(m) @@ -8139,6 +7601,7 @@ def __init__(self, m=None): super().__init__(m) def fromJson(self, m): + import tercen.model.impl as impl super().fromJson(m) self.subKind = m.get(Vocabulary.SUBKIND) if self.subKind is None and m.get(Vocabulary.KIND) != Vocabulary.ShinyOperator_CLASS: @@ -8146,9 +7609,10 @@ def fromJson(self, m): @classmethod def createFromJson(cls, m): + import tercen.model.impl as impl kind = m.get(Vocabulary.KIND) if kind == Vocabulary.ShinyOperator_CLASS: - return ShinyOperator(m) + return impl.ShinyOperator(m) raise ValueError("bad kind : " + kind + " for class ShinyOperator in createFromJson") @@ -8162,16 +7626,10 @@ def toJson(self): return m -class ShinyOperator(ShinyOperatorBase): - def __init__(self, m=None): - super().__init__(m) - - -class ErrorsBase(SciObject): +class ErrorsBase: def __init__(self, m=None): import tercen.model.impl as impl - if ("SciObject", impl.SciObject) in inspect.getmembers(impl): - ErrorsBase.__bases__ = (impl.SciObject,) + ErrorsBase.__bases__ = (impl.SciObject,) if m is None: super().__init__(m) self.factors = list() @@ -8179,6 +7637,7 @@ def __init__(self, m=None): self.fromJson(m) def fromJson(self, m): + import tercen.model.impl as impl super().fromJson(m) self.subKind = m.get(Vocabulary.SUBKIND) if self.subKind is None and m.get(Vocabulary.KIND) != Vocabulary.Errors_CLASS: @@ -8192,9 +7651,10 @@ def fromJson(self, m): @classmethod def createFromJson(cls, m): + import tercen.model.impl as impl kind = m.get(Vocabulary.KIND) if kind == Vocabulary.Errors_CLASS: - return Errors(m) + return impl.Errors(m) raise ValueError("bad kind : " + kind + " for class Errors in createFromJson") @@ -8210,16 +7670,10 @@ def toJson(self): return m -class Errors(ErrorsBase): - def __init__(self, m=None): - super().__init__(m) - - -class GlTaskBase(Task): +class GlTaskBase: def __init__(self, m=None): import tercen.model.impl as impl - if ("Task", impl.Task) in inspect.getmembers(impl): - GlTaskBase.__bases__ = (impl.Task,) + GlTaskBase.__bases__ = (impl.Task,) if m is None: super().__init__(m) self.glQuery = "" @@ -8227,6 +7681,7 @@ def __init__(self, m=None): self.fromJson(m) def fromJson(self, m): + import tercen.model.impl as impl super().fromJson(m) self.subKind = m.get(Vocabulary.SUBKIND) if self.subKind is None and m.get(Vocabulary.KIND) != Vocabulary.GlTask_CLASS: @@ -8235,9 +7690,10 @@ def fromJson(self, m): @classmethod def createFromJson(cls, m): + import tercen.model.impl as impl kind = m.get(Vocabulary.KIND) if kind == Vocabulary.GlTask_CLASS: - return GlTask(m) + return impl.GlTask(m) raise ValueError("bad kind : " + kind + " for class GlTask in createFromJson") @@ -8252,16 +7708,10 @@ def toJson(self): return m -class GlTask(GlTaskBase): - def __init__(self, m=None): - super().__init__(m) - - -class FailedStateBase(State): +class FailedStateBase: def __init__(self, m=None): import tercen.model.impl as impl - if ("State", impl.State) in inspect.getmembers(impl): - FailedStateBase.__bases__ = (impl.State,) + FailedStateBase.__bases__ = (impl.State,) if m is None: super().__init__(m) self.error = "" @@ -8270,6 +7720,7 @@ def __init__(self, m=None): self.fromJson(m) def fromJson(self, m): + import tercen.model.impl as impl super().fromJson(m) self.subKind = m.get(Vocabulary.SUBKIND) if self.subKind is None and m.get(Vocabulary.KIND) != Vocabulary.FailedState_CLASS: @@ -8279,9 +7730,10 @@ def fromJson(self, m): @classmethod def createFromJson(cls, m): + import tercen.model.impl as impl kind = m.get(Vocabulary.KIND) if kind == Vocabulary.FailedState_CLASS: - return FailedState(m) + return impl.FailedState(m) raise ValueError("bad kind : " + kind + " for class FailedState in createFromJson") @@ -8297,16 +7749,10 @@ def toJson(self): return m -class FailedState(FailedStateBase): - def __init__(self, m=None): - super().__init__(m) - - -class CanceledStateBase(State): +class CanceledStateBase: def __init__(self, m=None): import tercen.model.impl as impl - if ("State", impl.State) in inspect.getmembers(impl): - CanceledStateBase.__bases__ = (impl.State,) + CanceledStateBase.__bases__ = (impl.State,) if m is not None: self.fromJson(m) @@ -8314,6 +7760,7 @@ def __init__(self, m=None): super().__init__(m) def fromJson(self, m): + import tercen.model.impl as impl super().fromJson(m) self.subKind = m.get(Vocabulary.SUBKIND) if self.subKind is None and m.get(Vocabulary.KIND) != Vocabulary.CanceledState_CLASS: @@ -8321,9 +7768,10 @@ def fromJson(self, m): @classmethod def createFromJson(cls, m): + import tercen.model.impl as impl kind = m.get(Vocabulary.KIND) if kind == Vocabulary.CanceledState_CLASS: - return CanceledState(m) + return impl.CanceledState(m) raise ValueError("bad kind : " + kind + " for class CanceledState in createFromJson") @@ -8337,16 +7785,10 @@ def toJson(self): return m -class CanceledState(CanceledStateBase): - def __init__(self, m=None): - super().__init__(m) - - -class RunWorkflowTaskBase(ProjectTask): +class RunWorkflowTaskBase: def __init__(self, m=None): import tercen.model.impl as impl - if ("ProjectTask", impl.ProjectTask) in inspect.getmembers(impl): - RunWorkflowTaskBase.__bases__ = (impl.ProjectTask,) + RunWorkflowTaskBase.__bases__ = (impl.ProjectTask,) if m is None: super().__init__(m) self.workflowId = "" @@ -8355,6 +7797,7 @@ def __init__(self, m=None): self.fromJson(m) def fromJson(self, m): + import tercen.model.impl as impl super().fromJson(m) self.subKind = m.get(Vocabulary.SUBKIND) if self.subKind is None and m.get(Vocabulary.KIND) != Vocabulary.RunWorkflowTask_CLASS: @@ -8364,9 +7807,10 @@ def fromJson(self, m): @classmethod def createFromJson(cls, m): + import tercen.model.impl as impl kind = m.get(Vocabulary.KIND) if kind == Vocabulary.RunWorkflowTask_CLASS: - return RunWorkflowTask(m) + return impl.RunWorkflowTask(m) raise ValueError("bad kind : " + kind + " for class RunWorkflowTask in createFromJson") @@ -8382,44 +7826,40 @@ def toJson(self): return m -class RunWorkflowTask(RunWorkflowTaskBase): - def __init__(self, m=None): - super().__init__(m) - - -class GraphicalFactorBase(SciObject): +class GraphicalFactorBase: def __init__(self, m=None): import tercen.model.impl as impl - if ("SciObject", impl.SciObject) in inspect.getmembers(impl): - GraphicalFactorBase.__bases__ = (impl.SciObject,) + GraphicalFactorBase.__bases__ = (impl.SciObject,) if m is None: super().__init__(m) - self.factor = Factor() - self.rectangle = Rectangle() + self.factor = impl.Factor() + self.rectangle = impl.Rectangle() else: self.fromJson(m) def fromJson(self, m): + import tercen.model.impl as impl super().fromJson(m) self.subKind = m.get(Vocabulary.SUBKIND) if self.subKind is None and m.get(Vocabulary.KIND) != Vocabulary.GraphicalFactor_CLASS: self.subKind = m.get(Vocabulary.KIND) if m.get(Vocabulary.factor_OP) is None: - self.factor = Factor() + self.factor = impl.Factor() else: self.factor = FactorBase.createFromJson( m.get(Vocabulary.factor_OP)) if m.get(Vocabulary.rectangle_OP) is None: - self.rectangle = Rectangle() + self.rectangle = impl.Rectangle() else: self.rectangle = RectangleBase.createFromJson( m.get(Vocabulary.rectangle_OP)) @classmethod def createFromJson(cls, m): + import tercen.model.impl as impl kind = m.get(Vocabulary.KIND) if kind == Vocabulary.GraphicalFactor_CLASS: - return GraphicalFactor(m) + return impl.GraphicalFactor(m) raise ValueError("bad kind : " + kind + " for class GraphicalFactor in createFromJson") @@ -8435,25 +7875,20 @@ def toJson(self): return m -class GraphicalFactor(GraphicalFactorBase): - def __init__(self, m=None): - super().__init__(m) - - -class RenameRelationBase(Relation): +class RenameRelationBase: def __init__(self, m=None): import tercen.model.impl as impl - if ("Relation", impl.Relation) in inspect.getmembers(impl): - RenameRelationBase.__bases__ = (impl.Relation,) + RenameRelationBase.__bases__ = (impl.Relation,) if m is None: super().__init__(m) self.inNames = list() self.outNames = list() - self.relation = Relation() + self.relation = impl.Relation() else: self.fromJson(m) def fromJson(self, m): + import tercen.model.impl as impl super().fromJson(m) self.subKind = m.get(Vocabulary.SUBKIND) if self.subKind is None and m.get(Vocabulary.KIND) != Vocabulary.RenameRelation_CLASS: @@ -8467,16 +7902,17 @@ def fromJson(self, m): else: self.outNames = m[Vocabulary.outNames_DP] if m.get(Vocabulary.relation_OP) is None: - self.relation = Relation() + self.relation = impl.Relation() else: self.relation = RelationBase.createFromJson( m.get(Vocabulary.relation_OP)) @classmethod def createFromJson(cls, m): + import tercen.model.impl as impl kind = m.get(Vocabulary.KIND) if kind == Vocabulary.RenameRelation_CLASS: - return RenameRelation(m) + return impl.RenameRelation(m) raise ValueError("bad kind : " + kind + " for class RenameRelation in createFromJson") @@ -8493,16 +7929,10 @@ def toJson(self): return m -class RenameRelation(RenameRelationBase): - def __init__(self, m=None): - super().__init__(m) - - -class ChartSizeBase(Chart): +class ChartSizeBase: def __init__(self, m=None): import tercen.model.impl as impl - if ("Chart", impl.Chart) in inspect.getmembers(impl): - ChartSizeBase.__bases__ = (impl.Chart,) + ChartSizeBase.__bases__ = (impl.Chart,) if m is None: super().__init__(m) self.pointSize = 0 @@ -8510,6 +7940,7 @@ def __init__(self, m=None): self.fromJson(m) def fromJson(self, m): + import tercen.model.impl as impl super().fromJson(m) self.subKind = m.get(Vocabulary.SUBKIND) if self.subKind is None and m.get(Vocabulary.KIND) != Vocabulary.ChartSize_CLASS: @@ -8518,13 +7949,14 @@ def fromJson(self, m): @classmethod def createFromJson(cls, m): + import tercen.model.impl as impl kind = m.get(Vocabulary.KIND) if kind == Vocabulary.ChartSize_CLASS: - return ChartSize(m) + return impl.ChartSize(m) if kind == Vocabulary.ChartLine_CLASS: - return ChartLine(m) + return impl.ChartLine(m) if kind == Vocabulary.ChartPoint_CLASS: - return ChartPoint(m) + return impl.ChartPoint(m) raise ValueError("bad kind : " + kind + " for class ChartSize in createFromJson") @@ -8539,16 +7971,10 @@ def toJson(self): return m -class ChartSize(ChartSizeBase): - def __init__(self, m=None): - super().__init__(m) - - -class ChartLineBase(ChartSize): +class ChartLineBase: def __init__(self, m=None): import tercen.model.impl as impl - if ("ChartSize", impl.ChartSize) in inspect.getmembers(impl): - ChartLineBase.__bases__ = (impl.ChartSize,) + ChartLineBase.__bases__ = (impl.ChartSize,) if m is not None: self.fromJson(m) @@ -8556,6 +7982,7 @@ def __init__(self, m=None): super().__init__(m) def fromJson(self, m): + import tercen.model.impl as impl super().fromJson(m) self.subKind = m.get(Vocabulary.SUBKIND) if self.subKind is None and m.get(Vocabulary.KIND) != Vocabulary.ChartLine_CLASS: @@ -8563,9 +7990,10 @@ def fromJson(self, m): @classmethod def createFromJson(cls, m): + import tercen.model.impl as impl kind = m.get(Vocabulary.KIND) if kind == Vocabulary.ChartLine_CLASS: - return ChartLine(m) + return impl.ChartLine(m) raise ValueError("bad kind : " + kind + " for class ChartLine in createFromJson") @@ -8579,16 +8007,10 @@ def toJson(self): return m -class ChartLine(ChartLineBase): - def __init__(self, m=None): - super().__init__(m) - - -class ColorListBase(SciObject): +class ColorListBase: def __init__(self, m=None): import tercen.model.impl as impl - if ("SciObject", impl.SciObject) in inspect.getmembers(impl): - ColorListBase.__bases__ = (impl.SciObject,) + ColorListBase.__bases__ = (impl.SciObject,) if m is None: super().__init__(m) self.name = "" @@ -8596,6 +8018,7 @@ def __init__(self, m=None): self.fromJson(m) def fromJson(self, m): + import tercen.model.impl as impl super().fromJson(m) self.subKind = m.get(Vocabulary.SUBKIND) if self.subKind is None and m.get(Vocabulary.KIND) != Vocabulary.ColorList_CLASS: @@ -8604,9 +8027,10 @@ def fromJson(self, m): @classmethod def createFromJson(cls, m): + import tercen.model.impl as impl kind = m.get(Vocabulary.KIND) if kind == Vocabulary.ColorList_CLASS: - return ColorList(m) + return impl.ColorList(m) raise ValueError("bad kind : " + kind + " for class ColorList in createFromJson") @@ -8621,40 +8045,36 @@ def toJson(self): return m -class ColorList(ColorListBase): - def __init__(self, m=None): - super().__init__(m) - - -class CrossTabStepBase(NamespaceStep): +class CrossTabStepBase: def __init__(self, m=None): import tercen.model.impl as impl - if ("NamespaceStep", impl.NamespaceStep) in inspect.getmembers(impl): - CrossTabStepBase.__bases__ = (impl.NamespaceStep,) + CrossTabStepBase.__bases__ = (impl.NamespaceStep,) if m is None: super().__init__(m) - self.model = Crosstab() + self.model = impl.Crosstab() else: self.fromJson(m) def fromJson(self, m): + import tercen.model.impl as impl super().fromJson(m) self.subKind = m.get(Vocabulary.SUBKIND) if self.subKind is None and m.get(Vocabulary.KIND) != Vocabulary.CrossTabStep_CLASS: self.subKind = m.get(Vocabulary.KIND) if m.get(Vocabulary.model_OP) is None: - self.model = Crosstab() + self.model = impl.Crosstab() else: self.model = CrosstabBase.createFromJson( m.get(Vocabulary.model_OP)) @classmethod def createFromJson(cls, m): + import tercen.model.impl as impl kind = m.get(Vocabulary.KIND) if kind == Vocabulary.CrossTabStep_CLASS: - return CrossTabStep(m) + return impl.CrossTabStep(m) if kind == Vocabulary.DataStep_CLASS: - return DataStep(m) + return impl.DataStep(m) raise ValueError("bad kind : " + kind + " for class CrossTabStep in createFromJson") @@ -8669,40 +8089,36 @@ def toJson(self): return m -class CrossTabStep(CrossTabStepBase): - def __init__(self, m=None): - super().__init__(m) - - -class DataStepBase(CrossTabStep): +class DataStepBase: def __init__(self, m=None): import tercen.model.impl as impl - if ("CrossTabStep", impl.CrossTabStep) in inspect.getmembers(impl): - DataStepBase.__bases__ = (impl.CrossTabStep,) + DataStepBase.__bases__ = (impl.CrossTabStep,) if m is None: super().__init__(m) self.parentDataStepId = "" - self.computedRelation = Relation() + self.computedRelation = impl.Relation() else: self.fromJson(m) def fromJson(self, m): + import tercen.model.impl as impl super().fromJson(m) self.subKind = m.get(Vocabulary.SUBKIND) if self.subKind is None and m.get(Vocabulary.KIND) != Vocabulary.DataStep_CLASS: self.subKind = m.get(Vocabulary.KIND) self.parentDataStepId = m[Vocabulary.parentDataStepId_DP] if m.get(Vocabulary.computedRelation_OP) is None: - self.computedRelation = Relation() + self.computedRelation = impl.Relation() else: self.computedRelation = RelationBase.createFromJson( m.get(Vocabulary.computedRelation_OP)) @classmethod def createFromJson(cls, m): + import tercen.model.impl as impl kind = m.get(Vocabulary.KIND) if kind == Vocabulary.DataStep_CLASS: - return DataStep(m) + return impl.DataStep(m) raise ValueError("bad kind : " + kind + " for class DataStep in createFromJson") @@ -8718,16 +8134,10 @@ def toJson(self): return m -class DataStep(DataStepBase): - def __init__(self, m=None): - super().__init__(m) - - -class SearchResultBase(SciObject): +class SearchResultBase: def __init__(self, m=None): import tercen.model.impl as impl - if ("SciObject", impl.SciObject) in inspect.getmembers(impl): - SearchResultBase.__bases__ = (impl.SciObject,) + SearchResultBase.__bases__ = (impl.SciObject,) if m is None: super().__init__(m) self.total_rows = 0 @@ -8737,6 +8147,7 @@ def __init__(self, m=None): self.fromJson(m) def fromJson(self, m): + import tercen.model.impl as impl super().fromJson(m) self.subKind = m.get(Vocabulary.SUBKIND) if self.subKind is None and m.get(Vocabulary.KIND) != Vocabulary.SearchResult_CLASS: @@ -8752,9 +8163,10 @@ def fromJson(self, m): @classmethod def createFromJson(cls, m): + import tercen.model.impl as impl kind = m.get(Vocabulary.KIND) if kind == Vocabulary.SearchResult_CLASS: - return SearchResult(m) + return impl.SearchResult(m) raise ValueError("bad kind : " + kind + " for class SearchResult in createFromJson") @@ -8771,16 +8183,10 @@ def toJson(self): return m -class SearchResult(SearchResultBase): - def __init__(self, m=None): - super().__init__(m) - - -class GateOperatorModelBase(OperatorModel): +class GateOperatorModelBase: def __init__(self, m=None): import tercen.model.impl as impl - if ("OperatorModel", impl.OperatorModel) in inspect.getmembers(impl): - GateOperatorModelBase.__bases__ = (impl.OperatorModel,) + GateOperatorModelBase.__bases__ = (impl.OperatorModel,) if m is None: super().__init__(m) self.roots = list() @@ -8788,6 +8194,7 @@ def __init__(self, m=None): self.fromJson(m) def fromJson(self, m): + import tercen.model.impl as impl super().fromJson(m) self.subKind = m.get(Vocabulary.SUBKIND) if self.subKind is None and m.get(Vocabulary.KIND) != Vocabulary.GateOperatorModel_CLASS: @@ -8801,9 +8208,10 @@ def fromJson(self, m): @classmethod def createFromJson(cls, m): + import tercen.model.impl as impl kind = m.get(Vocabulary.KIND) if kind == Vocabulary.GateOperatorModel_CLASS: - return GateOperatorModel(m) + return impl.GateOperatorModel(m) raise ValueError("bad kind : " + kind + " for class GateOperatorModel in createFromJson") @@ -8818,26 +8226,21 @@ def toJson(self): return m -class GateOperatorModel(GateOperatorModelBase): - def __init__(self, m=None): - super().__init__(m) - - -class AnnotationModelBase(SciObject): +class AnnotationModelBase: def __init__(self, m=None): import tercen.model.impl as impl - if ("SciObject", impl.SciObject) in inspect.getmembers(impl): - AnnotationModelBase.__bases__ = (impl.SciObject,) + AnnotationModelBase.__bases__ = (impl.SciObject,) if m is None: super().__init__(m) self.taskId = "" self.factors = list() self.annotationFactors = list() - self.relation = Relation() + self.relation = impl.Relation() else: self.fromJson(m) def fromJson(self, m): + import tercen.model.impl as impl super().fromJson(m) self.subKind = m.get(Vocabulary.SUBKIND) if self.subKind is None and m.get(Vocabulary.KIND) != Vocabulary.AnnotationModel_CLASS: @@ -8857,16 +8260,17 @@ def fromJson(self, m): self.annotationFactors.append( GraphicalFactorBase.createFromJson(o)) if m.get(Vocabulary.relation_OP) is None: - self.relation = Relation() + self.relation = impl.Relation() else: self.relation = RelationBase.createFromJson( m.get(Vocabulary.relation_OP)) @classmethod def createFromJson(cls, m): + import tercen.model.impl as impl kind = m.get(Vocabulary.KIND) if kind == Vocabulary.AnnotationModel_CLASS: - return AnnotationModel(m) + return impl.AnnotationModel(m) raise ValueError("bad kind : " + kind + " for class AnnotationModel in createFromJson") @@ -8886,16 +8290,10 @@ def toJson(self): return m -class AnnotationModel(AnnotationModelBase): - def __init__(self, m=None): - super().__init__(m) - - -class ROperatorBase(GitOperator): +class ROperatorBase: def __init__(self, m=None): import tercen.model.impl as impl - if ("GitOperator", impl.GitOperator) in inspect.getmembers(impl): - ROperatorBase.__bases__ = (impl.GitOperator,) + ROperatorBase.__bases__ = (impl.GitOperator,) if m is not None: self.fromJson(m) @@ -8903,6 +8301,7 @@ def __init__(self, m=None): super().__init__(m) def fromJson(self, m): + import tercen.model.impl as impl super().fromJson(m) self.subKind = m.get(Vocabulary.SUBKIND) if self.subKind is None and m.get(Vocabulary.KIND) != Vocabulary.ROperator_CLASS: @@ -8910,9 +8309,10 @@ def fromJson(self, m): @classmethod def createFromJson(cls, m): + import tercen.model.impl as impl kind = m.get(Vocabulary.KIND) if kind == Vocabulary.ROperator_CLASS: - return ROperator(m) + return impl.ROperator(m) raise ValueError("bad kind : " + kind + " for class ROperator in createFromJson") @@ -8926,38 +8326,34 @@ def toJson(self): return m -class ROperator(ROperatorBase): - def __init__(self, m=None): - super().__init__(m) - - -class OutStepBase(RelationStep): +class OutStepBase: def __init__(self, m=None): import tercen.model.impl as impl - if ("RelationStep", impl.RelationStep) in inspect.getmembers(impl): - OutStepBase.__bases__ = (impl.RelationStep,) + OutStepBase.__bases__ = (impl.RelationStep,) if m is None: super().__init__(m) - self.groupPortPosition = Point() + self.groupPortPosition = impl.Point() else: self.fromJson(m) def fromJson(self, m): + import tercen.model.impl as impl super().fromJson(m) self.subKind = m.get(Vocabulary.SUBKIND) if self.subKind is None and m.get(Vocabulary.KIND) != Vocabulary.OutStep_CLASS: self.subKind = m.get(Vocabulary.KIND) if m.get(Vocabulary.groupPortPosition_OP) is None: - self.groupPortPosition = Point() + self.groupPortPosition = impl.Point() else: self.groupPortPosition = PointBase.createFromJson( m.get(Vocabulary.groupPortPosition_OP)) @classmethod def createFromJson(cls, m): + import tercen.model.impl as impl kind = m.get(Vocabulary.KIND) if kind == Vocabulary.OutStep_CLASS: - return OutStep(m) + return impl.OutStep(m) raise ValueError("bad kind : " + kind + " for class OutStep in createFromJson") @@ -8972,16 +8368,10 @@ def toJson(self): return m -class OutStep(OutStepBase): - def __init__(self, m=None): - super().__init__(m) - - -class LibraryTaskBase(Task): +class LibraryTaskBase: def __init__(self, m=None): import tercen.model.impl as impl - if ("Task", impl.Task) in inspect.getmembers(impl): - LibraryTaskBase.__bases__ = (impl.Task,) + LibraryTaskBase.__bases__ = (impl.Task,) if m is not None: self.fromJson(m) @@ -8989,6 +8379,7 @@ def __init__(self, m=None): super().__init__(m) def fromJson(self, m): + import tercen.model.impl as impl super().fromJson(m) self.subKind = m.get(Vocabulary.SUBKIND) if self.subKind is None and m.get(Vocabulary.KIND) != Vocabulary.LibraryTask_CLASS: @@ -8996,9 +8387,10 @@ def fromJson(self, m): @classmethod def createFromJson(cls, m): + import tercen.model.impl as impl kind = m.get(Vocabulary.KIND) if kind == Vocabulary.LibraryTask_CLASS: - return LibraryTask(m) + return impl.LibraryTask(m) raise ValueError("bad kind : " + kind + " for class LibraryTask in createFromJson") @@ -9012,40 +8404,36 @@ def toJson(self): return m -class LibraryTask(LibraryTaskBase): - def __init__(self, m=None): - super().__init__(m) - - -class PreProcessorBase(SciObject): +class PreProcessorBase: def __init__(self, m=None): import tercen.model.impl as impl - if ("SciObject", impl.SciObject) in inspect.getmembers(impl): - PreProcessorBase.__bases__ = (impl.SciObject,) + PreProcessorBase.__bases__ = (impl.SciObject,) if m is None: super().__init__(m) self.type = "" - self.operatorRef = OperatorRef() + self.operatorRef = impl.OperatorRef() else: self.fromJson(m) def fromJson(self, m): + import tercen.model.impl as impl super().fromJson(m) self.subKind = m.get(Vocabulary.SUBKIND) if self.subKind is None and m.get(Vocabulary.KIND) != Vocabulary.PreProcessor_CLASS: self.subKind = m.get(Vocabulary.KIND) self.type = m[Vocabulary.type_DP] if m.get(Vocabulary.operatorRef_OP) is None: - self.operatorRef = OperatorRef() + self.operatorRef = impl.OperatorRef() else: self.operatorRef = OperatorRefBase.createFromJson( m.get(Vocabulary.operatorRef_OP)) @classmethod def createFromJson(cls, m): + import tercen.model.impl as impl kind = m.get(Vocabulary.KIND) if kind == Vocabulary.PreProcessor_CLASS: - return PreProcessor(m) + return impl.PreProcessor(m) raise ValueError("bad kind : " + kind + " for class PreProcessor in createFromJson") @@ -9061,16 +8449,10 @@ def toJson(self): return m -class PreProcessor(PreProcessorBase): - def __init__(self, m=None): - super().__init__(m) - - -class PortBase(IdObject): +class PortBase: def __init__(self, m=None): import tercen.model.impl as impl - if ("IdObject", impl.IdObject) in inspect.getmembers(impl): - PortBase.__bases__ = (impl.IdObject,) + PortBase.__bases__ = (impl.IdObject,) if m is None: super().__init__(m) self.linkType = "" @@ -9079,6 +8461,7 @@ def __init__(self, m=None): self.fromJson(m) def fromJson(self, m): + import tercen.model.impl as impl super().fromJson(m) self.subKind = m.get(Vocabulary.SUBKIND) if self.subKind is None and m.get(Vocabulary.KIND) != Vocabulary.Port_CLASS: @@ -9088,13 +8471,14 @@ def fromJson(self, m): @classmethod def createFromJson(cls, m): + import tercen.model.impl as impl kind = m.get(Vocabulary.KIND) if kind == Vocabulary.Port_CLASS: - return Port(m) + return impl.Port(m) if kind == Vocabulary.InputPort_CLASS: - return InputPort(m) + return impl.InputPort(m) if kind == Vocabulary.OutputPort_CLASS: - return OutputPort(m) + return impl.OutputPort(m) raise ValueError("bad kind : " + kind + " for class Port in createFromJson") @@ -9110,16 +8494,10 @@ def toJson(self): return m -class Port(PortBase): - def __init__(self, m=None): - super().__init__(m) - - -class InputPortBase(Port): +class InputPortBase: def __init__(self, m=None): import tercen.model.impl as impl - if ("Port", impl.Port) in inspect.getmembers(impl): - InputPortBase.__bases__ = (impl.Port,) + InputPortBase.__bases__ = (impl.Port,) if m is not None: self.fromJson(m) @@ -9127,6 +8505,7 @@ def __init__(self, m=None): super().__init__(m) def fromJson(self, m): + import tercen.model.impl as impl super().fromJson(m) self.subKind = m.get(Vocabulary.SUBKIND) if self.subKind is None and m.get(Vocabulary.KIND) != Vocabulary.InputPort_CLASS: @@ -9134,9 +8513,10 @@ def fromJson(self, m): @classmethod def createFromJson(cls, m): + import tercen.model.impl as impl kind = m.get(Vocabulary.KIND) if kind == Vocabulary.InputPort_CLASS: - return InputPort(m) + return impl.InputPort(m) raise ValueError("bad kind : " + kind + " for class InputPort in createFromJson") @@ -9150,16 +8530,10 @@ def toJson(self): return m -class InputPort(InputPortBase): - def __init__(self, m=None): - super().__init__(m) - - -class PropertiesBase(SciObject): +class PropertiesBase: def __init__(self, m=None): import tercen.model.impl as impl - if ("SciObject", impl.SciObject) in inspect.getmembers(impl): - PropertiesBase.__bases__ = (impl.SciObject,) + PropertiesBase.__bases__ = (impl.SciObject,) if m is None: super().__init__(m) self.properties = list() @@ -9168,6 +8542,7 @@ def __init__(self, m=None): self.fromJson(m) def fromJson(self, m): + import tercen.model.impl as impl super().fromJson(m) self.subKind = m.get(Vocabulary.SUBKIND) if self.subKind is None and m.get(Vocabulary.KIND) != Vocabulary.Properties_CLASS: @@ -9187,9 +8562,10 @@ def fromJson(self, m): @classmethod def createFromJson(cls, m): + import tercen.model.impl as impl kind = m.get(Vocabulary.KIND) if kind == Vocabulary.Properties_CLASS: - return Properties(m) + return impl.Properties(m) raise ValueError("bad kind : " + kind + " for class Properties in createFromJson") @@ -9207,16 +8583,10 @@ def toJson(self): return m -class Properties(PropertiesBase): - def __init__(self, m=None): - super().__init__(m) - - -class PropertyValueBase(SciObject): +class PropertyValueBase: def __init__(self, m=None): import tercen.model.impl as impl - if ("SciObject", impl.SciObject) in inspect.getmembers(impl): - PropertyValueBase.__bases__ = (impl.SciObject,) + PropertyValueBase.__bases__ = (impl.SciObject,) if m is None: super().__init__(m) self.name = "" @@ -9225,6 +8595,7 @@ def __init__(self, m=None): self.fromJson(m) def fromJson(self, m): + import tercen.model.impl as impl super().fromJson(m) self.subKind = m.get(Vocabulary.SUBKIND) if self.subKind is None and m.get(Vocabulary.KIND) != Vocabulary.PropertyValue_CLASS: @@ -9234,9 +8605,10 @@ def fromJson(self, m): @classmethod def createFromJson(cls, m): + import tercen.model.impl as impl kind = m.get(Vocabulary.KIND) if kind == Vocabulary.PropertyValue_CLASS: - return PropertyValue(m) + return impl.PropertyValue(m) raise ValueError("bad kind : " + kind + " for class PropertyValue in createFromJson") @@ -9252,16 +8624,10 @@ def toJson(self): return m -class PropertyValue(PropertyValueBase): - def __init__(self, m=None): - super().__init__(m) - - -class DoneStateBase(State): +class DoneStateBase: def __init__(self, m=None): import tercen.model.impl as impl - if ("State", impl.State) in inspect.getmembers(impl): - DoneStateBase.__bases__ = (impl.State,) + DoneStateBase.__bases__ = (impl.State,) if m is not None: self.fromJson(m) @@ -9269,6 +8635,7 @@ def __init__(self, m=None): super().__init__(m) def fromJson(self, m): + import tercen.model.impl as impl super().fromJson(m) self.subKind = m.get(Vocabulary.SUBKIND) if self.subKind is None and m.get(Vocabulary.KIND) != Vocabulary.DoneState_CLASS: @@ -9276,9 +8643,10 @@ def fromJson(self, m): @classmethod def createFromJson(cls, m): + import tercen.model.impl as impl kind = m.get(Vocabulary.KIND) if kind == Vocabulary.DoneState_CLASS: - return DoneState(m) + return impl.DoneState(m) raise ValueError("bad kind : " + kind + " for class DoneState in createFromJson") @@ -9292,16 +8660,10 @@ def toJson(self): return m -class DoneState(DoneStateBase): - def __init__(self, m=None): - super().__init__(m) - - -class AclContextBase(SciObject): +class AclContextBase: def __init__(self, m=None): import tercen.model.impl as impl - if ("SciObject", impl.SciObject) in inspect.getmembers(impl): - AclContextBase.__bases__ = (impl.SciObject,) + AclContextBase.__bases__ = (impl.SciObject,) if m is None: super().__init__(m) self.username = "" @@ -9310,6 +8672,7 @@ def __init__(self, m=None): self.fromJson(m) def fromJson(self, m): + import tercen.model.impl as impl super().fromJson(m) self.subKind = m.get(Vocabulary.SUBKIND) if self.subKind is None and m.get(Vocabulary.KIND) != Vocabulary.AclContext_CLASS: @@ -9319,9 +8682,10 @@ def fromJson(self, m): @classmethod def createFromJson(cls, m): + import tercen.model.impl as impl kind = m.get(Vocabulary.KIND) if kind == Vocabulary.AclContext_CLASS: - return AclContext(m) + return impl.AclContext(m) raise ValueError("bad kind : " + kind + " for class AclContext in createFromJson") @@ -9334,19 +8698,13 @@ def toJson(self): m.pop(Vocabulary.SUBKIND, None) m[Vocabulary.username_DP] = self.username m[Vocabulary.domain_DP] = self.domain - return m - - -class AclContext(AclContextBase): - def __init__(self, m=None): - super().__init__(m) + return m -class DockerWebAppOperatorBase(WebAppOperator): +class DockerWebAppOperatorBase: def __init__(self, m=None): import tercen.model.impl as impl - if ("WebAppOperator", impl.WebAppOperator) in inspect.getmembers(impl): - DockerWebAppOperatorBase.__bases__ = (impl.WebAppOperator,) + DockerWebAppOperatorBase.__bases__ = (impl.WebAppOperator,) if m is None: super().__init__(m) self.container = "" @@ -9354,6 +8712,7 @@ def __init__(self, m=None): self.fromJson(m) def fromJson(self, m): + import tercen.model.impl as impl super().fromJson(m) self.subKind = m.get(Vocabulary.SUBKIND) if self.subKind is None and m.get(Vocabulary.KIND) != Vocabulary.DockerWebAppOperator_CLASS: @@ -9362,9 +8721,10 @@ def fromJson(self, m): @classmethod def createFromJson(cls, m): + import tercen.model.impl as impl kind = m.get(Vocabulary.KIND) if kind == Vocabulary.DockerWebAppOperator_CLASS: - return DockerWebAppOperator(m) + return impl.DockerWebAppOperator(m) raise ValueError("bad kind : " + kind + " for class DockerWebAppOperator in createFromJson") @@ -9379,16 +8739,10 @@ def toJson(self): return m -class DockerWebAppOperator(DockerWebAppOperatorBase): - def __init__(self, m=None): - super().__init__(m) - - -class OperatorUnitTestBase(SciObject): +class OperatorUnitTestBase: def __init__(self, m=None): import tercen.model.impl as impl - if ("SciObject", impl.SciObject) in inspect.getmembers(impl): - OperatorUnitTestBase.__bases__ = (impl.SciObject,) + OperatorUnitTestBase.__bases__ = (impl.SciObject,) if m is None: super().__init__(m) self.name = "" @@ -9412,6 +8766,7 @@ def __init__(self, m=None): self.fromJson(m) def fromJson(self, m): + import tercen.model.impl as impl super().fromJson(m) self.subKind = m.get(Vocabulary.SUBKIND) if self.subKind is None and m.get(Vocabulary.KIND) != Vocabulary.OperatorUnitTest_CLASS: @@ -9462,9 +8817,10 @@ def fromJson(self, m): @classmethod def createFromJson(cls, m): + import tercen.model.impl as impl kind = m.get(Vocabulary.KIND) if kind == Vocabulary.OperatorUnitTest_CLASS: - return OperatorUnitTest(m) + return impl.OperatorUnitTest(m) raise ValueError("bad kind : " + kind + " for class OperatorUnitTest in createFromJson") @@ -9496,38 +8852,34 @@ def toJson(self): return m -class OperatorUnitTest(OperatorUnitTestBase): - def __init__(self, m=None): - super().__init__(m) - - -class TableStepBase(RelationStep): +class TableStepBase: def __init__(self, m=None): import tercen.model.impl as impl - if ("RelationStep", impl.RelationStep) in inspect.getmembers(impl): - TableStepBase.__bases__ = (impl.RelationStep,) + TableStepBase.__bases__ = (impl.RelationStep,) if m is None: super().__init__(m) - self.model = TableStepModel() + self.model = impl.TableStepModel() else: self.fromJson(m) def fromJson(self, m): + import tercen.model.impl as impl super().fromJson(m) self.subKind = m.get(Vocabulary.SUBKIND) if self.subKind is None and m.get(Vocabulary.KIND) != Vocabulary.TableStep_CLASS: self.subKind = m.get(Vocabulary.KIND) if m.get(Vocabulary.model_OP) is None: - self.model = TableStepModel() + self.model = impl.TableStepModel() else: self.model = TableStepModelBase.createFromJson( m.get(Vocabulary.model_OP)) @classmethod def createFromJson(cls, m): + import tercen.model.impl as impl kind = m.get(Vocabulary.KIND) if kind == Vocabulary.TableStep_CLASS: - return TableStep(m) + return impl.TableStep(m) raise ValueError("bad kind : " + kind + " for class TableStep in createFromJson") @@ -9542,25 +8894,20 @@ def toJson(self): return m -class TableStep(TableStepBase): - def __init__(self, m=None): - super().__init__(m) - - -class RunWebAppTaskBase(ProjectTask): +class RunWebAppTaskBase: def __init__(self, m=None): import tercen.model.impl as impl - if ("ProjectTask", impl.ProjectTask) in inspect.getmembers(impl): - RunWebAppTaskBase.__bases__ = (impl.ProjectTask,) + RunWebAppTaskBase.__bases__ = (impl.ProjectTask,) if m is None: super().__init__(m) self.operatorId = "" self.cubeQueryTaskId = "" - self.url = Url() + self.url = impl.Url() else: self.fromJson(m) def fromJson(self, m): + import tercen.model.impl as impl super().fromJson(m) self.subKind = m.get(Vocabulary.SUBKIND) if self.subKind is None and m.get(Vocabulary.KIND) != Vocabulary.RunWebAppTask_CLASS: @@ -9568,15 +8915,16 @@ def fromJson(self, m): self.operatorId = m[Vocabulary.operatorId_DP] self.cubeQueryTaskId = m[Vocabulary.cubeQueryTaskId_DP] if m.get(Vocabulary.url_OP) is None: - self.url = Url() + self.url = impl.Url() else: self.url = UrlBase.createFromJson(m.get(Vocabulary.url_OP)) @classmethod def createFromJson(cls, m): + import tercen.model.impl as impl kind = m.get(Vocabulary.KIND) if kind == Vocabulary.RunWebAppTask_CLASS: - return RunWebAppTask(m) + return impl.RunWebAppTask(m) raise ValueError("bad kind : " + kind + " for class RunWebAppTask in createFromJson") @@ -9593,16 +8941,10 @@ def toJson(self): return m -class RunWebAppTask(RunWebAppTaskBase): - def __init__(self, m=None): - super().__init__(m) - - -class UnionRelationBase(Relation): +class UnionRelationBase: def __init__(self, m=None): import tercen.model.impl as impl - if ("Relation", impl.Relation) in inspect.getmembers(impl): - UnionRelationBase.__bases__ = (impl.Relation,) + UnionRelationBase.__bases__ = (impl.Relation,) if m is None: super().__init__(m) self.relations = list() @@ -9610,6 +8952,7 @@ def __init__(self, m=None): self.fromJson(m) def fromJson(self, m): + import tercen.model.impl as impl super().fromJson(m) self.subKind = m.get(Vocabulary.SUBKIND) if self.subKind is None and m.get(Vocabulary.KIND) != Vocabulary.UnionRelation_CLASS: @@ -9623,9 +8966,10 @@ def fromJson(self, m): @classmethod def createFromJson(cls, m): + import tercen.model.impl as impl kind = m.get(Vocabulary.KIND) if kind == Vocabulary.UnionRelation_CLASS: - return UnionRelation(m) + return impl.UnionRelation(m) raise ValueError("bad kind : " + kind + " for class UnionRelation in createFromJson") @@ -9641,62 +8985,58 @@ def toJson(self): return m -class UnionRelation(UnionRelationBase): - def __init__(self, m=None): - super().__init__(m) - - -class ProfilesBase(SciObject): +class ProfilesBase: def __init__(self, m=None): import tercen.model.impl as impl - if ("SciObject", impl.SciObject) in inspect.getmembers(impl): - ProfilesBase.__bases__ = (impl.SciObject,) + ProfilesBase.__bases__ = (impl.SciObject,) if m is None: super().__init__(m) - self.apiProfile = ApiCallProfile() - self.tableProfile = TableProfile() - self.cpuTimeProfile = CpuTimeProfile() - self.storageProfile = StorageProfile() - self.runProfile = RunProfile() + self.apiProfile = impl.ApiCallProfile() + self.tableProfile = impl.TableProfile() + self.cpuTimeProfile = impl.CpuTimeProfile() + self.storageProfile = impl.StorageProfile() + self.runProfile = impl.RunProfile() else: self.fromJson(m) def fromJson(self, m): + import tercen.model.impl as impl super().fromJson(m) self.subKind = m.get(Vocabulary.SUBKIND) if self.subKind is None and m.get(Vocabulary.KIND) != Vocabulary.Profiles_CLASS: self.subKind = m.get(Vocabulary.KIND) if m.get(Vocabulary.apiProfile_OP) is None: - self.apiProfile = ApiCallProfile() + self.apiProfile = impl.ApiCallProfile() else: self.apiProfile = ApiCallProfileBase.createFromJson( m.get(Vocabulary.apiProfile_OP)) if m.get(Vocabulary.tableProfile_OP) is None: - self.tableProfile = TableProfile() + self.tableProfile = impl.TableProfile() else: self.tableProfile = TableProfileBase.createFromJson( m.get(Vocabulary.tableProfile_OP)) if m.get(Vocabulary.cpuTimeProfile_OP) is None: - self.cpuTimeProfile = CpuTimeProfile() + self.cpuTimeProfile = impl.CpuTimeProfile() else: self.cpuTimeProfile = CpuTimeProfileBase.createFromJson( m.get(Vocabulary.cpuTimeProfile_OP)) if m.get(Vocabulary.storageProfile_OP) is None: - self.storageProfile = StorageProfile() + self.storageProfile = impl.StorageProfile() else: self.storageProfile = StorageProfileBase.createFromJson( m.get(Vocabulary.storageProfile_OP)) if m.get(Vocabulary.runProfile_OP) is None: - self.runProfile = RunProfile() + self.runProfile = impl.RunProfile() else: self.runProfile = RunProfileBase.createFromJson( m.get(Vocabulary.runProfile_OP)) @classmethod def createFromJson(cls, m): + import tercen.model.impl as impl kind = m.get(Vocabulary.KIND) if kind == Vocabulary.Profiles_CLASS: - return Profiles(m) + return impl.Profiles(m) raise ValueError("bad kind : " + kind + " for class Profiles in createFromJson") @@ -9715,25 +9055,20 @@ def toJson(self): return m -class Profiles(ProfilesBase): - def __init__(self, m=None): - super().__init__(m) - - -class FilterExprBase(FilterTopExpr): +class FilterExprBase: def __init__(self, m=None): import tercen.model.impl as impl - if ("FilterTopExpr", impl.FilterTopExpr) in inspect.getmembers(impl): - FilterExprBase.__bases__ = (impl.FilterTopExpr,) + FilterExprBase.__bases__ = (impl.FilterTopExpr,) if m is None: super().__init__(m) self.filterOp = "" self.stringValue = "" - self.factor = Factor() + self.factor = impl.Factor() else: self.fromJson(m) def fromJson(self, m): + import tercen.model.impl as impl super().fromJson(m) self.subKind = m.get(Vocabulary.SUBKIND) if self.subKind is None and m.get(Vocabulary.KIND) != Vocabulary.FilterExpr_CLASS: @@ -9741,18 +9076,19 @@ def fromJson(self, m): self.filterOp = m[Vocabulary.filterOp_DP] self.stringValue = m[Vocabulary.stringValue_DP] if m.get(Vocabulary.factor_OP) is None: - self.factor = Factor() + self.factor = impl.Factor() else: self.factor = FactorBase.createFromJson( m.get(Vocabulary.factor_OP)) @classmethod def createFromJson(cls, m): + import tercen.model.impl as impl kind = m.get(Vocabulary.KIND) if kind == Vocabulary.FilterExpr_CLASS: - return FilterExpr(m) + return impl.FilterExpr(m) if kind == Vocabulary.FilterExpr2d_CLASS: - return FilterExpr2d(m) + return impl.FilterExpr2d(m) raise ValueError("bad kind : " + kind + " for class FilterExpr in createFromJson") @@ -9769,38 +9105,34 @@ def toJson(self): return m -class FilterExpr(FilterExprBase): - def __init__(self, m=None): - super().__init__(m) - - -class FilterExpr2dBase(FilterExpr): +class FilterExpr2dBase: def __init__(self, m=None): import tercen.model.impl as impl - if ("FilterExpr", impl.FilterExpr) in inspect.getmembers(impl): - FilterExpr2dBase.__bases__ = (impl.FilterExpr,) + FilterExpr2dBase.__bases__ = (impl.FilterExpr,) if m is None: super().__init__(m) - self.factor2 = Factor() + self.factor2 = impl.Factor() else: self.fromJson(m) def fromJson(self, m): + import tercen.model.impl as impl super().fromJson(m) self.subKind = m.get(Vocabulary.SUBKIND) if self.subKind is None and m.get(Vocabulary.KIND) != Vocabulary.FilterExpr2d_CLASS: self.subKind = m.get(Vocabulary.KIND) if m.get(Vocabulary.factor2_OP) is None: - self.factor2 = Factor() + self.factor2 = impl.Factor() else: self.factor2 = FactorBase.createFromJson( m.get(Vocabulary.factor2_OP)) @classmethod def createFromJson(cls, m): + import tercen.model.impl as impl kind = m.get(Vocabulary.KIND) if kind == Vocabulary.FilterExpr2d_CLASS: - return FilterExpr2d(m) + return impl.FilterExpr2d(m) raise ValueError("bad kind : " + kind + " for class FilterExpr2d in createFromJson") @@ -9815,16 +9147,10 @@ def toJson(self): return m -class FilterExpr2d(FilterExpr2dBase): - def __init__(self, m=None): - super().__init__(m) - - -class FactorsPropertyBase(StringProperty): +class FactorsPropertyBase: def __init__(self, m=None): import tercen.model.impl as impl - if ("StringProperty", impl.StringProperty) in inspect.getmembers(impl): - FactorsPropertyBase.__bases__ = (impl.StringProperty,) + FactorsPropertyBase.__bases__ = (impl.StringProperty,) if m is not None: self.fromJson(m) @@ -9832,6 +9158,7 @@ def __init__(self, m=None): super().__init__(m) def fromJson(self, m): + import tercen.model.impl as impl super().fromJson(m) self.subKind = m.get(Vocabulary.SUBKIND) if self.subKind is None and m.get(Vocabulary.KIND) != Vocabulary.FactorsProperty_CLASS: @@ -9839,9 +9166,10 @@ def fromJson(self, m): @classmethod def createFromJson(cls, m): + import tercen.model.impl as impl kind = m.get(Vocabulary.KIND) if kind == Vocabulary.FactorsProperty_CLASS: - return FactorsProperty(m) + return impl.FactorsProperty(m) raise ValueError("bad kind : " + kind + " for class FactorsProperty in createFromJson") @@ -9855,16 +9183,10 @@ def toJson(self): return m -class FactorsProperty(FactorsPropertyBase): - def __init__(self, m=None): - super().__init__(m) - - -class OperatorRefBase(SciObject): +class OperatorRefBase: def __init__(self, m=None): import tercen.model.impl as impl - if ("SciObject", impl.SciObject) in inspect.getmembers(impl): - OperatorRefBase.__bases__ = (impl.SciObject,) + OperatorRefBase.__bases__ = (impl.SciObject,) if m is None: super().__init__(m) self.name = "" @@ -9872,11 +9194,12 @@ def __init__(self, m=None): self.operatorId = "" self.operatorKind = "" self.propertyValues = list() - self.url = Url() + self.url = impl.Url() else: self.fromJson(m) def fromJson(self, m): + import tercen.model.impl as impl super().fromJson(m) self.subKind = m.get(Vocabulary.SUBKIND) if self.subKind is None and m.get(Vocabulary.KIND) != Vocabulary.OperatorRef_CLASS: @@ -9892,15 +9215,16 @@ def fromJson(self, m): for o in m.get(Vocabulary.propertyValues_OP): self.propertyValues.append(PropertyValueBase.createFromJson(o)) if m.get(Vocabulary.url_OP) is None: - self.url = Url() + self.url = impl.Url() else: self.url = UrlBase.createFromJson(m.get(Vocabulary.url_OP)) @classmethod def createFromJson(cls, m): + import tercen.model.impl as impl kind = m.get(Vocabulary.KIND) if kind == Vocabulary.OperatorRef_CLASS: - return OperatorRef(m) + return impl.OperatorRef(m) raise ValueError("bad kind : " + kind + " for class OperatorRef in createFromJson") @@ -9921,30 +9245,25 @@ def toJson(self): return m -class OperatorRef(OperatorRefBase): - def __init__(self, m=None): - super().__init__(m) - - -class JoinStepBase(NamespaceStep): +class JoinStepBase: def __init__(self, m=None): import tercen.model.impl as impl - if ("NamespaceStep", impl.NamespaceStep) in inspect.getmembers(impl): - JoinStepBase.__bases__ = (impl.NamespaceStep,) + JoinStepBase.__bases__ = (impl.NamespaceStep,) if m is None: super().__init__(m) - self.model = JoinStepModel() + self.model = impl.JoinStepModel() self.rightAttributes = list() else: self.fromJson(m) def fromJson(self, m): + import tercen.model.impl as impl super().fromJson(m) self.subKind = m.get(Vocabulary.SUBKIND) if self.subKind is None and m.get(Vocabulary.KIND) != Vocabulary.JoinStep_CLASS: self.subKind = m.get(Vocabulary.KIND) if m.get(Vocabulary.model_OP) is None: - self.model = JoinStepModel() + self.model = impl.JoinStepModel() else: self.model = JoinStepModelBase.createFromJson( m.get(Vocabulary.model_OP)) @@ -9957,9 +9276,10 @@ def fromJson(self, m): @classmethod def createFromJson(cls, m): + import tercen.model.impl as impl kind = m.get(Vocabulary.KIND) if kind == Vocabulary.JoinStep_CLASS: - return JoinStep(m) + return impl.JoinStep(m) raise ValueError("bad kind : " + kind + " for class JoinStep in createFromJson") @@ -9976,38 +9296,34 @@ def toJson(self): return m -class JoinStep(JoinStepBase): - def __init__(self, m=None): - super().__init__(m) - - -class WizardStepBase(NamespaceStep): +class WizardStepBase: def __init__(self, m=None): import tercen.model.impl as impl - if ("NamespaceStep", impl.NamespaceStep) in inspect.getmembers(impl): - WizardStepBase.__bases__ = (impl.NamespaceStep,) + WizardStepBase.__bases__ = (impl.NamespaceStep,) if m is None: super().__init__(m) - self.model = WizardStepModel() + self.model = impl.WizardStepModel() else: self.fromJson(m) def fromJson(self, m): + import tercen.model.impl as impl super().fromJson(m) self.subKind = m.get(Vocabulary.SUBKIND) if self.subKind is None and m.get(Vocabulary.KIND) != Vocabulary.WizardStep_CLASS: self.subKind = m.get(Vocabulary.KIND) if m.get(Vocabulary.model_OP) is None: - self.model = WizardStepModel() + self.model = impl.WizardStepModel() else: self.model = WizardStepModelBase.createFromJson( m.get(Vocabulary.model_OP)) @classmethod def createFromJson(cls, m): + import tercen.model.impl as impl kind = m.get(Vocabulary.KIND) if kind == Vocabulary.WizardStep_CLASS: - return WizardStep(m) + return impl.WizardStep(m) raise ValueError("bad kind : " + kind + " for class WizardStep in createFromJson") @@ -10022,16 +9338,10 @@ def toJson(self): return m -class WizardStep(WizardStepBase): - def __init__(self, m=None): - super().__init__(m) - - -class WizardStepModelBase(StepModel): +class WizardStepModelBase: def __init__(self, m=None): import tercen.model.impl as impl - if ("StepModel", impl.StepModel) in inspect.getmembers(impl): - WizardStepModelBase.__bases__ = (impl.StepModel,) + WizardStepModelBase.__bases__ = (impl.StepModel,) if m is None: super().__init__(m) self.namespace = "" @@ -10046,6 +9356,7 @@ def __init__(self, m=None): self.fromJson(m) def fromJson(self, m): + import tercen.model.impl as impl super().fromJson(m) self.subKind = m.get(Vocabulary.SUBKIND) if self.subKind is None and m.get(Vocabulary.KIND) != Vocabulary.WizardStepModel_CLASS: @@ -10086,9 +9397,10 @@ def fromJson(self, m): @classmethod def createFromJson(cls, m): + import tercen.model.impl as impl kind = m.get(Vocabulary.KIND) if kind == Vocabulary.WizardStepModel_CLASS: - return WizardStepModel(m) + return impl.WizardStepModel(m) raise ValueError("bad kind : " + kind + " for class WizardStepModel in createFromJson") @@ -10114,16 +9426,10 @@ def toJson(self): return m -class WizardStepModel(WizardStepModelBase): - def __init__(self, m=None): - super().__init__(m) - - -class InitStateBase(State): +class InitStateBase: def __init__(self, m=None): import tercen.model.impl as impl - if ("State", impl.State) in inspect.getmembers(impl): - InitStateBase.__bases__ = (impl.State,) + InitStateBase.__bases__ = (impl.State,) if m is not None: self.fromJson(m) @@ -10131,6 +9437,7 @@ def __init__(self, m=None): super().__init__(m) def fromJson(self, m): + import tercen.model.impl as impl super().fromJson(m) self.subKind = m.get(Vocabulary.SUBKIND) if self.subKind is None and m.get(Vocabulary.KIND) != Vocabulary.InitState_CLASS: @@ -10138,9 +9445,10 @@ def fromJson(self, m): @classmethod def createFromJson(cls, m): + import tercen.model.impl as impl kind = m.get(Vocabulary.KIND) if kind == Vocabulary.InitState_CLASS: - return InitState(m) + return impl.InitState(m) raise ValueError("bad kind : " + kind + " for class InitState in createFromJson") @@ -10154,16 +9462,10 @@ def toJson(self): return m -class InitState(InitStateBase): - def __init__(self, m=None): - super().__init__(m) - - -class PendingStateBase(State): +class PendingStateBase: def __init__(self, m=None): import tercen.model.impl as impl - if ("State", impl.State) in inspect.getmembers(impl): - PendingStateBase.__bases__ = (impl.State,) + PendingStateBase.__bases__ = (impl.State,) if m is not None: self.fromJson(m) @@ -10171,6 +9473,7 @@ def __init__(self, m=None): super().__init__(m) def fromJson(self, m): + import tercen.model.impl as impl super().fromJson(m) self.subKind = m.get(Vocabulary.SUBKIND) if self.subKind is None and m.get(Vocabulary.KIND) != Vocabulary.PendingState_CLASS: @@ -10178,9 +9481,10 @@ def fromJson(self, m): @classmethod def createFromJson(cls, m): + import tercen.model.impl as impl kind = m.get(Vocabulary.KIND) if kind == Vocabulary.PendingState_CLASS: - return PendingState(m) + return impl.PendingState(m) raise ValueError("bad kind : " + kind + " for class PendingState in createFromJson") @@ -10194,16 +9498,10 @@ def toJson(self): return m -class PendingState(PendingStateBase): - def __init__(self, m=None): - super().__init__(m) - - -class ChartPointBase(ChartSize): +class ChartPointBase: def __init__(self, m=None): import tercen.model.impl as impl - if ("ChartSize", impl.ChartSize) in inspect.getmembers(impl): - ChartPointBase.__bases__ = (impl.ChartSize,) + ChartPointBase.__bases__ = (impl.ChartSize,) if m is not None: self.fromJson(m) @@ -10211,6 +9509,7 @@ def __init__(self, m=None): super().__init__(m) def fromJson(self, m): + import tercen.model.impl as impl super().fromJson(m) self.subKind = m.get(Vocabulary.SUBKIND) if self.subKind is None and m.get(Vocabulary.KIND) != Vocabulary.ChartPoint_CLASS: @@ -10218,9 +9517,10 @@ def fromJson(self, m): @classmethod def createFromJson(cls, m): + import tercen.model.impl as impl kind = m.get(Vocabulary.KIND) if kind == Vocabulary.ChartPoint_CLASS: - return ChartPoint(m) + return impl.ChartPoint(m) raise ValueError("bad kind : " + kind + " for class ChartPoint in createFromJson") @@ -10234,16 +9534,10 @@ def toJson(self): return m -class ChartPoint(ChartPointBase): - def __init__(self, m=None): - super().__init__(m) - - -class ColumnPairBase(SciObject): +class ColumnPairBase: def __init__(self, m=None): import tercen.model.impl as impl - if ("SciObject", impl.SciObject) in inspect.getmembers(impl): - ColumnPairBase.__bases__ = (impl.SciObject,) + ColumnPairBase.__bases__ = (impl.SciObject,) if m is None: super().__init__(m) self.lColumns = list() @@ -10252,6 +9546,7 @@ def __init__(self, m=None): self.fromJson(m) def fromJson(self, m): + import tercen.model.impl as impl super().fromJson(m) self.subKind = m.get(Vocabulary.SUBKIND) if self.subKind is None and m.get(Vocabulary.KIND) != Vocabulary.ColumnPair_CLASS: @@ -10267,9 +9562,10 @@ def fromJson(self, m): @classmethod def createFromJson(cls, m): + import tercen.model.impl as impl kind = m.get(Vocabulary.KIND) if kind == Vocabulary.ColumnPair_CLASS: - return ColumnPair(m) + return impl.ColumnPair(m) raise ValueError("bad kind : " + kind + " for class ColumnPair in createFromJson") @@ -10285,27 +9581,22 @@ def toJson(self): return m -class ColumnPair(ColumnPairBase): - def __init__(self, m=None): - super().__init__(m) - - -class CreateGitOperatorTaskBase(Task): +class CreateGitOperatorTaskBase: def __init__(self, m=None): import tercen.model.impl as impl - if ("Task", impl.Task) in inspect.getmembers(impl): - CreateGitOperatorTaskBase.__bases__ = (impl.Task,) + CreateGitOperatorTaskBase.__bases__ = (impl.Task,) if m is None: super().__init__(m) self.version = "" self.operatorId = "" self.gitToken = "" self.testRequired = True - self.url = Url() + self.url = impl.Url() else: self.fromJson(m) def fromJson(self, m): + import tercen.model.impl as impl super().fromJson(m) self.subKind = m.get(Vocabulary.SUBKIND) if self.subKind is None and m.get(Vocabulary.KIND) != Vocabulary.CreateGitOperatorTask_CLASS: @@ -10315,15 +9606,16 @@ def fromJson(self, m): self.gitToken = m[Vocabulary.gitToken_DP] self.testRequired = m[Vocabulary.testRequired_DP] if m.get(Vocabulary.url_OP) is None: - self.url = Url() + self.url = impl.Url() else: self.url = UrlBase.createFromJson(m.get(Vocabulary.url_OP)) @classmethod def createFromJson(cls, m): + import tercen.model.impl as impl kind = m.get(Vocabulary.KIND) if kind == Vocabulary.CreateGitOperatorTask_CLASS: - return CreateGitOperatorTask(m) + return impl.CreateGitOperatorTask(m) raise ValueError("bad kind : " + kind + " for class CreateGitOperatorTask in createFromJson") @@ -10342,16 +9634,10 @@ def toJson(self): return m -class CreateGitOperatorTask(CreateGitOperatorTaskBase): - def __init__(self, m=None): - super().__init__(m) - - -class TaxIdBase(SciObject): +class TaxIdBase: def __init__(self, m=None): import tercen.model.impl as impl - if ("SciObject", impl.SciObject) in inspect.getmembers(impl): - TaxIdBase.__bases__ = (impl.SciObject,) + TaxIdBase.__bases__ = (impl.SciObject,) if m is None: super().__init__(m) self.type = "" @@ -10361,6 +9647,7 @@ def __init__(self, m=None): self.fromJson(m) def fromJson(self, m): + import tercen.model.impl as impl super().fromJson(m) self.subKind = m.get(Vocabulary.SUBKIND) if self.subKind is None and m.get(Vocabulary.KIND) != Vocabulary.TaxId_CLASS: @@ -10371,9 +9658,10 @@ def fromJson(self, m): @classmethod def createFromJson(cls, m): + import tercen.model.impl as impl kind = m.get(Vocabulary.KIND) if kind == Vocabulary.TaxId_CLASS: - return TaxId(m) + return impl.TaxId(m) raise ValueError("bad kind : " + kind + " for class TaxId in createFromJson") @@ -10390,16 +9678,10 @@ def toJson(self): return m -class TaxId(TaxIdBase): - def __init__(self, m=None): - super().__init__(m) - - -class IssueMessageBase(ProjectDocument): +class IssueMessageBase: def __init__(self, m=None): import tercen.model.impl as impl - if ("ProjectDocument", impl.ProjectDocument) in inspect.getmembers(impl): - IssueMessageBase.__bases__ = (impl.ProjectDocument,) + IssueMessageBase.__bases__ = (impl.ProjectDocument,) if m is None: super().__init__(m) self.issueId = "" @@ -10408,6 +9690,7 @@ def __init__(self, m=None): self.fromJson(m) def fromJson(self, m): + import tercen.model.impl as impl super().fromJson(m) self.subKind = m.get(Vocabulary.SUBKIND) if self.subKind is None and m.get(Vocabulary.KIND) != Vocabulary.IssueMessage_CLASS: @@ -10417,9 +9700,10 @@ def fromJson(self, m): @classmethod def createFromJson(cls, m): + import tercen.model.impl as impl kind = m.get(Vocabulary.KIND) if kind == Vocabulary.IssueMessage_CLASS: - return IssueMessage(m) + return impl.IssueMessage(m) raise ValueError("bad kind : " + kind + " for class IssueMessage in createFromJson") @@ -10435,16 +9719,10 @@ def toJson(self): return m -class IssueMessage(IssueMessageBase): - def __init__(self, m=None): - super().__init__(m) - - -class TableSchemaBase(Schema): +class TableSchemaBase: def __init__(self, m=None): import tercen.model.impl as impl - if ("Schema", impl.Schema) in inspect.getmembers(impl): - TableSchemaBase.__bases__ = (impl.Schema,) + TableSchemaBase.__bases__ = (impl.Schema,) if m is not None: self.fromJson(m) @@ -10452,6 +9730,7 @@ def __init__(self, m=None): super().__init__(m) def fromJson(self, m): + import tercen.model.impl as impl super().fromJson(m) self.subKind = m.get(Vocabulary.SUBKIND) if self.subKind is None and m.get(Vocabulary.KIND) != Vocabulary.TableSchema_CLASS: @@ -10459,9 +9738,10 @@ def fromJson(self, m): @classmethod def createFromJson(cls, m): + import tercen.model.impl as impl kind = m.get(Vocabulary.KIND) if kind == Vocabulary.TableSchema_CLASS: - return TableSchema(m) + return impl.TableSchema(m) raise ValueError("bad kind : " + kind + " for class TableSchema in createFromJson") @@ -10475,16 +9755,10 @@ def toJson(self): return m -class TableSchema(TableSchemaBase): - def __init__(self, m=None): - super().__init__(m) - - -class PlanBase(SciObject): +class PlanBase: def __init__(self, m=None): import tercen.model.impl as impl - if ("SciObject", impl.SciObject) in inspect.getmembers(impl): - PlanBase.__bases__ = (impl.SciObject,) + PlanBase.__bases__ = (impl.SciObject,) if m is None: super().__init__(m) self.name = "" @@ -10496,6 +9770,7 @@ def __init__(self, m=None): self.fromJson(m) def fromJson(self, m): + import tercen.model.impl as impl super().fromJson(m) self.subKind = m.get(Vocabulary.SUBKIND) if self.subKind is None and m.get(Vocabulary.KIND) != Vocabulary.Plan_CLASS: @@ -10511,9 +9786,10 @@ def fromJson(self, m): @classmethod def createFromJson(cls, m): + import tercen.model.impl as impl kind = m.get(Vocabulary.KIND) if kind == Vocabulary.Plan_CLASS: - return Plan(m) + return impl.Plan(m) raise ValueError("bad kind : " + kind + " for class Plan in createFromJson") @@ -10532,16 +9808,10 @@ def toJson(self): return m -class Plan(PlanBase): - def __init__(self, m=None): - super().__init__(m) - - -class CSVParserParamBase(SciObject): +class CSVParserParamBase: def __init__(self, m=None): import tercen.model.impl as impl - if ("SciObject", impl.SciObject) in inspect.getmembers(impl): - CSVParserParamBase.__bases__ = (impl.SciObject,) + CSVParserParamBase.__bases__ = (impl.SciObject,) if m is None: super().__init__(m) self.separator = "" @@ -10554,6 +9824,7 @@ def __init__(self, m=None): self.fromJson(m) def fromJson(self, m): + import tercen.model.impl as impl super().fromJson(m) self.subKind = m.get(Vocabulary.SUBKIND) if self.subKind is None and m.get(Vocabulary.KIND) != Vocabulary.CSVParserParam_CLASS: @@ -10567,9 +9838,10 @@ def fromJson(self, m): @classmethod def createFromJson(cls, m): + import tercen.model.impl as impl kind = m.get(Vocabulary.KIND) if kind == Vocabulary.CSVParserParam_CLASS: - return CSVParserParam(m) + return impl.CSVParserParam(m) raise ValueError("bad kind : " + kind + " for class CSVParserParam in createFromJson") @@ -10589,16 +9861,10 @@ def toJson(self): return m -class CSVParserParam(CSVParserParamBase): - def __init__(self, m=None): - super().__init__(m) - - -class ExportTableTaskBase(ProjectTask): +class ExportTableTaskBase: def __init__(self, m=None): import tercen.model.impl as impl - if ("ProjectTask", impl.ProjectTask) in inspect.getmembers(impl): - ExportTableTaskBase.__bases__ = (impl.ProjectTask,) + ExportTableTaskBase.__bases__ = (impl.ProjectTask,) if m is None: super().__init__(m) self.exportName = "" @@ -10612,6 +9878,7 @@ def __init__(self, m=None): self.fromJson(m) def fromJson(self, m): + import tercen.model.impl as impl super().fromJson(m) self.subKind = m.get(Vocabulary.SUBKIND) if self.subKind is None and m.get(Vocabulary.KIND) != Vocabulary.ExportTableTask_CLASS: @@ -10635,9 +9902,10 @@ def fromJson(self, m): @classmethod def createFromJson(cls, m): + import tercen.model.impl as impl kind = m.get(Vocabulary.KIND) if kind == Vocabulary.ExportTableTask_CLASS: - return ExportTableTask(m) + return impl.ExportTableTask(m) raise ValueError("bad kind : " + kind + " for class ExportTableTask in createFromJson") @@ -10658,16 +9926,10 @@ def toJson(self): return m -class ExportTableTask(ExportTableTaskBase): - def __init__(self, m=None): - super().__init__(m) - - -class GenericEventBase(Event): +class GenericEventBase: def __init__(self, m=None): import tercen.model.impl as impl - if ("Event", impl.Event) in inspect.getmembers(impl): - GenericEventBase.__bases__ = (impl.Event,) + GenericEventBase.__bases__ = (impl.Event,) if m is None: super().__init__(m) self.type = "" @@ -10676,6 +9938,7 @@ def __init__(self, m=None): self.fromJson(m) def fromJson(self, m): + import tercen.model.impl as impl super().fromJson(m) self.subKind = m.get(Vocabulary.SUBKIND) if self.subKind is None and m.get(Vocabulary.KIND) != Vocabulary.GenericEvent_CLASS: @@ -10685,9 +9948,10 @@ def fromJson(self, m): @classmethod def createFromJson(cls, m): + import tercen.model.impl as impl kind = m.get(Vocabulary.KIND) if kind == Vocabulary.GenericEvent_CLASS: - return GenericEvent(m) + return impl.GenericEvent(m) raise ValueError("bad kind : " + kind + " for class GenericEvent in createFromJson") @@ -10703,16 +9967,10 @@ def toJson(self): return m -class GenericEvent(GenericEventBase): - def __init__(self, m=None): - super().__init__(m) - - -class OutputPortBase(Port): +class OutputPortBase: def __init__(self, m=None): import tercen.model.impl as impl - if ("Port", impl.Port) in inspect.getmembers(impl): - OutputPortBase.__bases__ = (impl.Port,) + OutputPortBase.__bases__ = (impl.Port,) if m is not None: self.fromJson(m) @@ -10720,6 +9978,7 @@ def __init__(self, m=None): super().__init__(m) def fromJson(self, m): + import tercen.model.impl as impl super().fromJson(m) self.subKind = m.get(Vocabulary.SUBKIND) if self.subKind is None and m.get(Vocabulary.KIND) != Vocabulary.OutputPort_CLASS: @@ -10727,9 +9986,10 @@ def fromJson(self, m): @classmethod def createFromJson(cls, m): + import tercen.model.impl as impl kind = m.get(Vocabulary.KIND) if kind == Vocabulary.OutputPort_CLASS: - return OutputPort(m) + return impl.OutputPort(m) raise ValueError("bad kind : " + kind + " for class OutputPort in createFromJson") @@ -10743,16 +10003,10 @@ def toJson(self): return m -class OutputPort(OutputPortBase): - def __init__(self, m=None): - super().__init__(m) - - -class LinkBase(IdObject): +class LinkBase: def __init__(self, m=None): import tercen.model.impl as impl - if ("IdObject", impl.IdObject) in inspect.getmembers(impl): - LinkBase.__bases__ = (impl.IdObject,) + LinkBase.__bases__ = (impl.IdObject,) if m is None: super().__init__(m) self.inputId = "" @@ -10761,6 +10015,7 @@ def __init__(self, m=None): self.fromJson(m) def fromJson(self, m): + import tercen.model.impl as impl super().fromJson(m) self.subKind = m.get(Vocabulary.SUBKIND) if self.subKind is None and m.get(Vocabulary.KIND) != Vocabulary.Link_CLASS: @@ -10770,9 +10025,10 @@ def fromJson(self, m): @classmethod def createFromJson(cls, m): + import tercen.model.impl as impl kind = m.get(Vocabulary.KIND) if kind == Vocabulary.Link_CLASS: - return Link(m) + return impl.Link(m) raise ValueError("bad kind : " + kind + " for class Link in createFromJson") @@ -10788,16 +10044,10 @@ def toJson(self): return m -class Link(LinkBase): - def __init__(self, m=None): - super().__init__(m) - - -class AppDesignBase(SciObject): +class AppDesignBase: def __init__(self, m=None): import tercen.model.impl as impl - if ("SciObject", impl.SciObject) in inspect.getmembers(impl): - AppDesignBase.__bases__ = (impl.SciObject,) + AppDesignBase.__bases__ = (impl.SciObject,) if m is None: super().__init__(m) self.namespace = "" @@ -10810,6 +10060,7 @@ def __init__(self, m=None): self.fromJson(m) def fromJson(self, m): + import tercen.model.impl as impl super().fromJson(m) self.subKind = m.get(Vocabulary.SUBKIND) if self.subKind is None and m.get(Vocabulary.KIND) != Vocabulary.AppDesign_CLASS: @@ -10833,9 +10084,10 @@ def fromJson(self, m): @classmethod def createFromJson(cls, m): + import tercen.model.impl as impl kind = m.get(Vocabulary.KIND) if kind == Vocabulary.AppDesign_CLASS: - return AppDesign(m) + return impl.AppDesign(m) raise ValueError("bad kind : " + kind + " for class AppDesign in createFromJson") @@ -10857,16 +10109,10 @@ def toJson(self): return m -class AppDesign(AppDesignBase): - def __init__(self, m=None): - super().__init__(m) - - -class GarbageTasks2Base(GarbageObject): +class GarbageTasks2Base: def __init__(self, m=None): import tercen.model.impl as impl - if ("GarbageObject", impl.GarbageObject) in inspect.getmembers(impl): - GarbageTasks2Base.__bases__ = (impl.GarbageObject,) + GarbageTasks2Base.__bases__ = (impl.GarbageObject,) if m is None: super().__init__(m) self.date = "" @@ -10878,6 +10124,7 @@ def __init__(self, m=None): self.fromJson(m) def fromJson(self, m): + import tercen.model.impl as impl super().fromJson(m) self.subKind = m.get(Vocabulary.SUBKIND) if self.subKind is None and m.get(Vocabulary.KIND) != Vocabulary.GarbageTasks2_CLASS: @@ -10899,9 +10146,10 @@ def fromJson(self, m): @classmethod def createFromJson(cls, m): + import tercen.model.impl as impl kind = m.get(Vocabulary.KIND) if kind == Vocabulary.GarbageTasks2_CLASS: - return GarbageTasks2(m) + return impl.GarbageTasks2(m) raise ValueError("bad kind : " + kind + " for class GarbageTasks2 in createFromJson") @@ -10920,25 +10168,20 @@ def toJson(self): return m -class GarbageTasks2(GarbageTasks2Base): - def __init__(self, m=None): - super().__init__(m) - - -class WorkflowBase(ProjectDocument): +class WorkflowBase: def __init__(self, m=None): import tercen.model.impl as impl - if ("ProjectDocument", impl.ProjectDocument) in inspect.getmembers(impl): - WorkflowBase.__bases__ = (impl.ProjectDocument,) + WorkflowBase.__bases__ = (impl.ProjectDocument,) if m is None: super().__init__(m) self.links = list() self.steps = list() - self.offset = Point() + self.offset = impl.Point() else: self.fromJson(m) def fromJson(self, m): + import tercen.model.impl as impl super().fromJson(m) self.subKind = m.get(Vocabulary.SUBKIND) if self.subKind is None and m.get(Vocabulary.KIND) != Vocabulary.Workflow_CLASS: @@ -10956,15 +10199,16 @@ def fromJson(self, m): for o in m.get(Vocabulary.steps_OP): self.steps.append(StepBase.createFromJson(o)) if m.get(Vocabulary.offset_OP) is None: - self.offset = Point() + self.offset = impl.Point() else: self.offset = PointBase.createFromJson(m.get(Vocabulary.offset_OP)) @classmethod def createFromJson(cls, m): + import tercen.model.impl as impl kind = m.get(Vocabulary.KIND) if kind == Vocabulary.Workflow_CLASS: - return Workflow(m) + return impl.Workflow(m) raise ValueError("bad kind : " + kind + " for class Workflow in createFromJson") @@ -10981,16 +10225,10 @@ def toJson(self): return m -class Workflow(WorkflowBase): - def __init__(self, m=None): - super().__init__(m) - - -class NamedFilterBase(Filter): +class NamedFilterBase: def __init__(self, m=None): import tercen.model.impl as impl - if ("Filter", impl.Filter) in inspect.getmembers(impl): - NamedFilterBase.__bases__ = (impl.Filter,) + NamedFilterBase.__bases__ = (impl.Filter,) if m is None: super().__init__(m) self.name = "" @@ -10999,6 +10237,7 @@ def __init__(self, m=None): self.fromJson(m) def fromJson(self, m): + import tercen.model.impl as impl super().fromJson(m) self.subKind = m.get(Vocabulary.SUBKIND) if self.subKind is None and m.get(Vocabulary.KIND) != Vocabulary.NamedFilter_CLASS: @@ -11013,9 +10252,10 @@ def fromJson(self, m): @classmethod def createFromJson(cls, m): + import tercen.model.impl as impl kind = m.get(Vocabulary.KIND) if kind == Vocabulary.NamedFilter_CLASS: - return NamedFilter(m) + return impl.NamedFilter(m) raise ValueError("bad kind : " + kind + " for class NamedFilter in createFromJson") @@ -11031,16 +10271,10 @@ def toJson(self): return m -class NamedFilter(NamedFilterBase): - def __init__(self, m=None): - super().__init__(m) - - -class TableProfileBase(Profile): +class TableProfileBase: def __init__(self, m=None): import tercen.model.impl as impl - if ("Profile", impl.Profile) in inspect.getmembers(impl): - TableProfileBase.__bases__ = (impl.Profile,) + TableProfileBase.__bases__ = (impl.Profile,) if m is None: super().__init__(m) self.nRows = 0 @@ -11049,6 +10283,7 @@ def __init__(self, m=None): self.fromJson(m) def fromJson(self, m): + import tercen.model.impl as impl super().fromJson(m) self.subKind = m.get(Vocabulary.SUBKIND) if self.subKind is None and m.get(Vocabulary.KIND) != Vocabulary.TableProfile_CLASS: @@ -11058,9 +10293,10 @@ def fromJson(self, m): @classmethod def createFromJson(cls, m): + import tercen.model.impl as impl kind = m.get(Vocabulary.KIND) if kind == Vocabulary.TableProfile_CLASS: - return TableProfile(m) + return impl.TableProfile(m) raise ValueError("bad kind : " + kind + " for class TableProfile in createFromJson") @@ -11076,16 +10312,10 @@ def toJson(self): return m -class TableProfile(TableProfileBase): - def __init__(self, m=None): - super().__init__(m) - - -class MeltStepModelBase(StepModel): +class MeltStepModelBase: def __init__(self, m=None): import tercen.model.impl as impl - if ("StepModel", impl.StepModel) in inspect.getmembers(impl): - MeltStepModelBase.__bases__ = (impl.StepModel,) + MeltStepModelBase.__bases__ = (impl.StepModel,) if m is None: super().__init__(m) self.namespace = "" @@ -11097,6 +10327,7 @@ def __init__(self, m=None): self.fromJson(m) def fromJson(self, m): + import tercen.model.impl as impl super().fromJson(m) self.subKind = m.get(Vocabulary.SUBKIND) if self.subKind is None and m.get(Vocabulary.KIND) != Vocabulary.MeltStepModel_CLASS: @@ -11114,9 +10345,10 @@ def fromJson(self, m): @classmethod def createFromJson(cls, m): + import tercen.model.impl as impl kind = m.get(Vocabulary.KIND) if kind == Vocabulary.MeltStepModel_CLASS: - return MeltStepModel(m) + return impl.MeltStepModel(m) raise ValueError("bad kind : " + kind + " for class MeltStepModel in createFromJson") @@ -11136,16 +10368,10 @@ def toJson(self): return m -class MeltStepModel(MeltStepModelBase): - def __init__(self, m=None): - super().__init__(m) - - -class ExportModelBase(StepModel): +class ExportModelBase: def __init__(self, m=None): import tercen.model.impl as impl - if ("StepModel", impl.StepModel) in inspect.getmembers(impl): - ExportModelBase.__bases__ = (impl.StepModel,) + ExportModelBase.__bases__ = (impl.StepModel,) if m is not None: self.fromJson(m) @@ -11153,6 +10379,7 @@ def __init__(self, m=None): super().__init__(m) def fromJson(self, m): + import tercen.model.impl as impl super().fromJson(m) self.subKind = m.get(Vocabulary.SUBKIND) if self.subKind is None and m.get(Vocabulary.KIND) != Vocabulary.ExportModel_CLASS: @@ -11160,9 +10387,10 @@ def fromJson(self, m): @classmethod def createFromJson(cls, m): + import tercen.model.impl as impl kind = m.get(Vocabulary.KIND) if kind == Vocabulary.ExportModel_CLASS: - return ExportModel(m) + return impl.ExportModel(m) raise ValueError("bad kind : " + kind + " for class ExportModel in createFromJson") @@ -11176,30 +10404,25 @@ def toJson(self): return m -class ExportModel(ExportModelBase): - def __init__(self, m=None): - super().__init__(m) - - -class AnnotationOperatorModelBase(OperatorModel): +class AnnotationOperatorModelBase: def __init__(self, m=None): import tercen.model.impl as impl - if ("OperatorModel", impl.OperatorModel) in inspect.getmembers(impl): - AnnotationOperatorModelBase.__bases__ = (impl.OperatorModel,) + AnnotationOperatorModelBase.__bases__ = (impl.OperatorModel,) if m is None: super().__init__(m) - self.filters = Filters() + self.filters = impl.Filters() self.annotationModels = list() else: self.fromJson(m) def fromJson(self, m): + import tercen.model.impl as impl super().fromJson(m) self.subKind = m.get(Vocabulary.SUBKIND) if self.subKind is None and m.get(Vocabulary.KIND) != Vocabulary.AnnotationOperatorModel_CLASS: self.subKind = m.get(Vocabulary.KIND) if m.get(Vocabulary.filters_OP) is None: - self.filters = Filters() + self.filters = impl.Filters() else: self.filters = FiltersBase.createFromJson( m.get(Vocabulary.filters_OP)) @@ -11213,9 +10436,10 @@ def fromJson(self, m): @classmethod def createFromJson(cls, m): + import tercen.model.impl as impl kind = m.get(Vocabulary.KIND) if kind == Vocabulary.AnnotationOperatorModel_CLASS: - return AnnotationOperatorModel(m) + return impl.AnnotationOperatorModel(m) raise ValueError("bad kind : " + kind + " for class AnnotationOperatorModel in createFromJson") @@ -11232,50 +10456,46 @@ def toJson(self): return m -class AnnotationOperatorModel(AnnotationOperatorModelBase): - def __init__(self, m=None): - super().__init__(m) - - -class AxisBase(SciObject): +class AxisBase: def __init__(self, m=None): import tercen.model.impl as impl - if ("SciObject", impl.SciObject) in inspect.getmembers(impl): - AxisBase.__bases__ = (impl.SciObject,) + AxisBase.__bases__ = (impl.SciObject,) if m is None: super().__init__(m) - self.axisExtent = Point() - self.axisSettings = AxisSettings() - self.graphicalFactor = GraphicalFactor() + self.axisExtent = impl.Point() + self.axisSettings = impl.AxisSettings() + self.graphicalFactor = impl.GraphicalFactor() else: self.fromJson(m) def fromJson(self, m): + import tercen.model.impl as impl super().fromJson(m) self.subKind = m.get(Vocabulary.SUBKIND) if self.subKind is None and m.get(Vocabulary.KIND) != Vocabulary.Axis_CLASS: self.subKind = m.get(Vocabulary.KIND) if m.get(Vocabulary.axisExtent_OP) is None: - self.axisExtent = Point() + self.axisExtent = impl.Point() else: self.axisExtent = PointBase.createFromJson( m.get(Vocabulary.axisExtent_OP)) if m.get(Vocabulary.axisSettings_OP) is None: - self.axisSettings = AxisSettings() + self.axisSettings = impl.AxisSettings() else: self.axisSettings = AxisSettingsBase.createFromJson( m.get(Vocabulary.axisSettings_OP)) if m.get(Vocabulary.graphicalFactor_OP) is None: - self.graphicalFactor = GraphicalFactor() + self.graphicalFactor = impl.GraphicalFactor() else: self.graphicalFactor = GraphicalFactorBase.createFromJson( m.get(Vocabulary.graphicalFactor_OP)) @classmethod def createFromJson(cls, m): + import tercen.model.impl as impl kind = m.get(Vocabulary.KIND) if kind == Vocabulary.Axis_CLASS: - return Axis(m) + return impl.Axis(m) raise ValueError("bad kind : " + kind + " for class Axis in createFromJson") @@ -11292,16 +10512,10 @@ def toJson(self): return m -class Axis(AxisBase): - def __init__(self, m=None): - super().__init__(m) - - -class BooleanPropertyBase(Property): +class BooleanPropertyBase: def __init__(self, m=None): import tercen.model.impl as impl - if ("Property", impl.Property) in inspect.getmembers(impl): - BooleanPropertyBase.__bases__ = (impl.Property,) + BooleanPropertyBase.__bases__ = (impl.Property,) if m is None: super().__init__(m) self.defaultValue = True @@ -11309,6 +10523,7 @@ def __init__(self, m=None): self.fromJson(m) def fromJson(self, m): + import tercen.model.impl as impl super().fromJson(m) self.subKind = m.get(Vocabulary.SUBKIND) if self.subKind is None and m.get(Vocabulary.KIND) != Vocabulary.BooleanProperty_CLASS: @@ -11317,9 +10532,10 @@ def fromJson(self, m): @classmethod def createFromJson(cls, m): + import tercen.model.impl as impl kind = m.get(Vocabulary.KIND) if kind == Vocabulary.BooleanProperty_CLASS: - return BooleanProperty(m) + return impl.BooleanProperty(m) raise ValueError("bad kind : " + kind + " for class BooleanProperty in createFromJson") @@ -11334,16 +10550,10 @@ def toJson(self): return m -class BooleanProperty(BooleanPropertyBase): - def __init__(self, m=None): - super().__init__(m) - - -class GatherRelationBase(Relation): +class GatherRelationBase: def __init__(self, m=None): import tercen.model.impl as impl - if ("Relation", impl.Relation) in inspect.getmembers(impl): - GatherRelationBase.__bases__ = (impl.Relation,) + GatherRelationBase.__bases__ = (impl.Relation,) if m is None: super().__init__(m) self.names = list() @@ -11351,11 +10561,12 @@ def __init__(self, m=None): self.variableName = "" self.valueType = "" self.gatherType = "" - self.relation = Relation() + self.relation = impl.Relation() else: self.fromJson(m) def fromJson(self, m): + import tercen.model.impl as impl super().fromJson(m) self.subKind = m.get(Vocabulary.SUBKIND) if self.subKind is None and m.get(Vocabulary.KIND) != Vocabulary.GatherRelation_CLASS: @@ -11369,16 +10580,17 @@ def fromJson(self, m): self.valueType = m[Vocabulary.valueType_DP] self.gatherType = m[Vocabulary.gatherType_DP] if m.get(Vocabulary.relation_OP) is None: - self.relation = Relation() + self.relation = impl.Relation() else: self.relation = RelationBase.createFromJson( m.get(Vocabulary.relation_OP)) @classmethod def createFromJson(cls, m): + import tercen.model.impl as impl kind = m.get(Vocabulary.KIND) if kind == Vocabulary.GatherRelation_CLASS: - return GatherRelation(m) + return impl.GatherRelation(m) raise ValueError("bad kind : " + kind + " for class GatherRelation in createFromJson") @@ -11398,38 +10610,34 @@ def toJson(self): return m -class GatherRelation(GatherRelationBase): - def __init__(self, m=None): - super().__init__(m) - - -class ExportStepBase(ModelStep): +class ExportStepBase: def __init__(self, m=None): import tercen.model.impl as impl - if ("ModelStep", impl.ModelStep) in inspect.getmembers(impl): - ExportStepBase.__bases__ = (impl.ModelStep,) + ExportStepBase.__bases__ = (impl.ModelStep,) if m is None: super().__init__(m) - self.model = ExportModel() + self.model = impl.ExportModel() else: self.fromJson(m) def fromJson(self, m): + import tercen.model.impl as impl super().fromJson(m) self.subKind = m.get(Vocabulary.SUBKIND) if self.subKind is None and m.get(Vocabulary.KIND) != Vocabulary.ExportStep_CLASS: self.subKind = m.get(Vocabulary.KIND) if m.get(Vocabulary.model_OP) is None: - self.model = ExportModel() + self.model = impl.ExportModel() else: self.model = ExportModelBase.createFromJson( m.get(Vocabulary.model_OP)) @classmethod def createFromJson(cls, m): + import tercen.model.impl as impl kind = m.get(Vocabulary.KIND) if kind == Vocabulary.ExportStep_CLASS: - return ExportStep(m) + return impl.ExportStep(m) raise ValueError("bad kind : " + kind + " for class ExportStep in createFromJson") @@ -11444,16 +10652,10 @@ def toJson(self): return m -class ExportStep(ExportStepBase): - def __init__(self, m=None): - super().__init__(m) - - -class ViewStepBase(Step): +class ViewStepBase: def __init__(self, m=None): import tercen.model.impl as impl - if ("Step", impl.Step) in inspect.getmembers(impl): - ViewStepBase.__bases__ = (impl.Step,) + ViewStepBase.__bases__ = (impl.Step,) if m is not None: self.fromJson(m) @@ -11461,6 +10663,7 @@ def __init__(self, m=None): super().__init__(m) def fromJson(self, m): + import tercen.model.impl as impl super().fromJson(m) self.subKind = m.get(Vocabulary.SUBKIND) if self.subKind is None and m.get(Vocabulary.KIND) != Vocabulary.ViewStep_CLASS: @@ -11468,9 +10671,10 @@ def fromJson(self, m): @classmethod def createFromJson(cls, m): + import tercen.model.impl as impl kind = m.get(Vocabulary.KIND) if kind == Vocabulary.ViewStep_CLASS: - return ViewStep(m) + return impl.ViewStep(m) raise ValueError("bad kind : " + kind + " for class ViewStep in createFromJson") @@ -11484,16 +10688,10 @@ def toJson(self): return m -class ViewStep(ViewStepBase): - def __init__(self, m=None): - super().__init__(m) - - -class ApiCallProfileBase(Profile): +class ApiCallProfileBase: def __init__(self, m=None): import tercen.model.impl as impl - if ("Profile", impl.Profile) in inspect.getmembers(impl): - ApiCallProfileBase.__bases__ = (impl.Profile,) + ApiCallProfileBase.__bases__ = (impl.Profile,) if m is None: super().__init__(m) self.nCalls = 0 @@ -11501,6 +10699,7 @@ def __init__(self, m=None): self.fromJson(m) def fromJson(self, m): + import tercen.model.impl as impl super().fromJson(m) self.subKind = m.get(Vocabulary.SUBKIND) if self.subKind is None and m.get(Vocabulary.KIND) != Vocabulary.ApiCallProfile_CLASS: @@ -11509,9 +10708,10 @@ def fromJson(self, m): @classmethod def createFromJson(cls, m): + import tercen.model.impl as impl kind = m.get(Vocabulary.KIND) if kind == Vocabulary.ApiCallProfile_CLASS: - return ApiCallProfile(m) + return impl.ApiCallProfile(m) raise ValueError("bad kind : " + kind + " for class ApiCallProfile in createFromJson") @@ -11526,24 +10726,19 @@ def toJson(self): return m -class ApiCallProfile(ApiCallProfileBase): - def __init__(self, m=None): - super().__init__(m) - - -class ColorsBase(SciObject): +class ColorsBase: def __init__(self, m=None): import tercen.model.impl as impl - if ("SciObject", impl.SciObject) in inspect.getmembers(impl): - ColorsBase.__bases__ = (impl.SciObject,) + ColorsBase.__bases__ = (impl.SciObject,) if m is None: super().__init__(m) self.factors = list() - self.palette = Palette() + self.palette = impl.Palette() else: self.fromJson(m) def fromJson(self, m): + import tercen.model.impl as impl super().fromJson(m) self.subKind = m.get(Vocabulary.SUBKIND) if self.subKind is None and m.get(Vocabulary.KIND) != Vocabulary.Colors_CLASS: @@ -11555,16 +10750,17 @@ def fromJson(self, m): for o in m.get(Vocabulary.factors_OP): self.factors.append(FactorBase.createFromJson(o)) if m.get(Vocabulary.palette_OP) is None: - self.palette = Palette() + self.palette = impl.Palette() else: self.palette = PaletteBase.createFromJson( m.get(Vocabulary.palette_OP)) @classmethod def createFromJson(cls, m): + import tercen.model.impl as impl kind = m.get(Vocabulary.KIND) if kind == Vocabulary.Colors_CLASS: - return Colors(m) + return impl.Colors(m) raise ValueError("bad kind : " + kind + " for class Colors in createFromJson") @@ -11581,24 +10777,19 @@ def toJson(self): return m -class Colors(ColorsBase): - def __init__(self, m=None): - super().__init__(m) - - -class CompositeRelationBase(Relation): +class CompositeRelationBase: def __init__(self, m=None): import tercen.model.impl as impl - if ("Relation", impl.Relation) in inspect.getmembers(impl): - CompositeRelationBase.__bases__ = (impl.Relation,) + CompositeRelationBase.__bases__ = (impl.Relation,) if m is None: super().__init__(m) self.joinOperators = list() - self.mainRelation = Relation() + self.mainRelation = impl.Relation() else: self.fromJson(m) def fromJson(self, m): + import tercen.model.impl as impl super().fromJson(m) self.subKind = m.get(Vocabulary.SUBKIND) if self.subKind is None and m.get(Vocabulary.KIND) != Vocabulary.CompositeRelation_CLASS: @@ -11610,16 +10801,17 @@ def fromJson(self, m): for o in m.get(Vocabulary.joinOperators_OP): self.joinOperators.append(JoinOperatorBase.createFromJson(o)) if m.get(Vocabulary.mainRelation_OP) is None: - self.mainRelation = Relation() + self.mainRelation = impl.Relation() else: self.mainRelation = RelationBase.createFromJson( m.get(Vocabulary.mainRelation_OP)) @classmethod def createFromJson(cls, m): + import tercen.model.impl as impl kind = m.get(Vocabulary.KIND) if kind == Vocabulary.CompositeRelation_CLASS: - return CompositeRelation(m) + return impl.CompositeRelation(m) raise ValueError("bad kind : " + kind + " for class CompositeRelation in createFromJson") @@ -11636,16 +10828,10 @@ def toJson(self): return m -class CompositeRelation(CompositeRelationBase): - def __init__(self, m=None): - super().__init__(m) - - -class GitProjectTaskBase(Task): +class GitProjectTaskBase: def __init__(self, m=None): import tercen.model.impl as impl - if ("Task", impl.Task) in inspect.getmembers(impl): - GitProjectTaskBase.__bases__ = (impl.Task,) + GitProjectTaskBase.__bases__ = (impl.Task,) if m is not None: self.fromJson(m) @@ -11653,6 +10839,7 @@ def __init__(self, m=None): super().__init__(m) def fromJson(self, m): + import tercen.model.impl as impl super().fromJson(m) self.subKind = m.get(Vocabulary.SUBKIND) if self.subKind is None and m.get(Vocabulary.KIND) != Vocabulary.GitProjectTask_CLASS: @@ -11660,9 +10847,10 @@ def fromJson(self, m): @classmethod def createFromJson(cls, m): + import tercen.model.impl as impl kind = m.get(Vocabulary.KIND) if kind == Vocabulary.GitProjectTask_CLASS: - return GitProjectTask(m) + return impl.GitProjectTask(m) raise ValueError("bad kind : " + kind + " for class GitProjectTask in createFromJson") @@ -11676,38 +10864,34 @@ def toJson(self): return m -class GitProjectTask(GitProjectTaskBase): - def __init__(self, m=None): - super().__init__(m) - - -class ComputedTableSchemaBase(Schema): +class ComputedTableSchemaBase: def __init__(self, m=None): import tercen.model.impl as impl - if ("Schema", impl.Schema) in inspect.getmembers(impl): - ComputedTableSchemaBase.__bases__ = (impl.Schema,) + ComputedTableSchemaBase.__bases__ = (impl.Schema,) if m is None: super().__init__(m) - self.query = CubeQuery() + self.query = impl.CubeQuery() else: self.fromJson(m) def fromJson(self, m): + import tercen.model.impl as impl super().fromJson(m) self.subKind = m.get(Vocabulary.SUBKIND) if self.subKind is None and m.get(Vocabulary.KIND) != Vocabulary.ComputedTableSchema_CLASS: self.subKind = m.get(Vocabulary.KIND) if m.get(Vocabulary.query_OP) is None: - self.query = CubeQuery() + self.query = impl.CubeQuery() else: self.query = CubeQueryBase.createFromJson( m.get(Vocabulary.query_OP)) @classmethod def createFromJson(cls, m): + import tercen.model.impl as impl kind = m.get(Vocabulary.KIND) if kind == Vocabulary.ComputedTableSchema_CLASS: - return ComputedTableSchema(m) + return impl.ComputedTableSchema(m) raise ValueError("bad kind : " + kind + " for class ComputedTableSchema in createFromJson") @@ -11722,16 +10906,10 @@ def toJson(self): return m -class ComputedTableSchema(ComputedTableSchemaBase): - def __init__(self, m=None): - super().__init__(m) - - -class TablePropertiesBase(SciObject): +class TablePropertiesBase: def __init__(self, m=None): import tercen.model.impl as impl - if ("SciObject", impl.SciObject) in inspect.getmembers(impl): - TablePropertiesBase.__bases__ = (impl.SciObject,) + TablePropertiesBase.__bases__ = (impl.SciObject,) if m is None: super().__init__(m) self.name = "" @@ -11741,6 +10919,7 @@ def __init__(self, m=None): self.fromJson(m) def fromJson(self, m): + import tercen.model.impl as impl super().fromJson(m) self.subKind = m.get(Vocabulary.SUBKIND) if self.subKind is None and m.get(Vocabulary.KIND) != Vocabulary.TableProperties_CLASS: @@ -11754,9 +10933,10 @@ def fromJson(self, m): @classmethod def createFromJson(cls, m): + import tercen.model.impl as impl kind = m.get(Vocabulary.KIND) if kind == Vocabulary.TableProperties_CLASS: - return TableProperties(m) + return impl.TableProperties(m) raise ValueError("bad kind : " + kind + " for class TableProperties in createFromJson") @@ -11773,16 +10953,10 @@ def toJson(self): return m -class TableProperties(TablePropertiesBase): - def __init__(self, m=None): - super().__init__(m) - - -class MappingFactorBase(Factor): +class MappingFactorBase: def __init__(self, m=None): import tercen.model.impl as impl - if ("Factor", impl.Factor) in inspect.getmembers(impl): - MappingFactorBase.__bases__ = (impl.Factor,) + MappingFactorBase.__bases__ = (impl.Factor,) if m is None: super().__init__(m) self.isSingle = True @@ -11794,6 +10968,7 @@ def __init__(self, m=None): self.fromJson(m) def fromJson(self, m): + import tercen.model.impl as impl super().fromJson(m) self.subKind = m.get(Vocabulary.SUBKIND) if self.subKind is None and m.get(Vocabulary.KIND) != Vocabulary.MappingFactor_CLASS: @@ -11811,9 +10986,10 @@ def fromJson(self, m): @classmethod def createFromJson(cls, m): + import tercen.model.impl as impl kind = m.get(Vocabulary.KIND) if kind == Vocabulary.MappingFactor_CLASS: - return MappingFactor(m) + return impl.MappingFactor(m) raise ValueError("bad kind : " + kind + " for class MappingFactor in createFromJson") @@ -11833,16 +11009,10 @@ def toJson(self): return m -class MappingFactor(MappingFactorBase): - def __init__(self, m=None): - super().__init__(m) - - -class SubscriptionPlanBase(Document): +class SubscriptionPlanBase: def __init__(self, m=None): import tercen.model.impl as impl - if ("Document", impl.Document) in inspect.getmembers(impl): - SubscriptionPlanBase.__bases__ = (impl.Document,) + SubscriptionPlanBase.__bases__ = (impl.Document,) if m is None: super().__init__(m) self.providerKey = "" @@ -11856,6 +11026,7 @@ def __init__(self, m=None): self.fromJson(m) def fromJson(self, m): + import tercen.model.impl as impl super().fromJson(m) self.subKind = m.get(Vocabulary.SUBKIND) if self.subKind is None and m.get(Vocabulary.KIND) != Vocabulary.SubscriptionPlan_CLASS: @@ -11870,9 +11041,10 @@ def fromJson(self, m): @classmethod def createFromJson(cls, m): + import tercen.model.impl as impl kind = m.get(Vocabulary.KIND) if kind == Vocabulary.SubscriptionPlan_CLASS: - return SubscriptionPlan(m) + return impl.SubscriptionPlan(m) raise ValueError("bad kind : " + kind + " for class SubscriptionPlan in createFromJson") @@ -11893,16 +11065,10 @@ def toJson(self): return m -class SubscriptionPlan(SubscriptionPlanBase): - def __init__(self, m=None): - super().__init__(m) - - -class FormulaPropertyBase(StringProperty): +class FormulaPropertyBase: def __init__(self, m=None): import tercen.model.impl as impl - if ("StringProperty", impl.StringProperty) in inspect.getmembers(impl): - FormulaPropertyBase.__bases__ = (impl.StringProperty,) + FormulaPropertyBase.__bases__ = (impl.StringProperty,) if m is not None: self.fromJson(m) @@ -11910,6 +11076,7 @@ def __init__(self, m=None): super().__init__(m) def fromJson(self, m): + import tercen.model.impl as impl super().fromJson(m) self.subKind = m.get(Vocabulary.SUBKIND) if self.subKind is None and m.get(Vocabulary.KIND) != Vocabulary.FormulaProperty_CLASS: @@ -11917,9 +11084,10 @@ def fromJson(self, m): @classmethod def createFromJson(cls, m): + import tercen.model.impl as impl kind = m.get(Vocabulary.KIND) if kind == Vocabulary.FormulaProperty_CLASS: - return FormulaProperty(m) + return impl.FormulaProperty(m) raise ValueError("bad kind : " + kind + " for class FormulaProperty in createFromJson") @@ -11933,16 +11101,10 @@ def toJson(self): return m -class FormulaProperty(FormulaPropertyBase): - def __init__(self, m=None): - super().__init__(m) - - -class UserSecretBase(PersistentObject): +class UserSecretBase: def __init__(self, m=None): import tercen.model.impl as impl - if ("PersistentObject", impl.PersistentObject) in inspect.getmembers(impl): - UserSecretBase.__bases__ = (impl.PersistentObject,) + UserSecretBase.__bases__ = (impl.PersistentObject,) if m is None: super().__init__(m) self.userId = "" @@ -11952,6 +11114,7 @@ def __init__(self, m=None): self.fromJson(m) def fromJson(self, m): + import tercen.model.impl as impl super().fromJson(m) self.subKind = m.get(Vocabulary.SUBKIND) if self.subKind is None and m.get(Vocabulary.KIND) != Vocabulary.UserSecret_CLASS: @@ -11962,9 +11125,10 @@ def fromJson(self, m): @classmethod def createFromJson(cls, m): + import tercen.model.impl as impl kind = m.get(Vocabulary.KIND) if kind == Vocabulary.UserSecret_CLASS: - return UserSecret(m) + return impl.UserSecret(m) raise ValueError("bad kind : " + kind + " for class UserSecret in createFromJson") @@ -11981,24 +11145,19 @@ def toJson(self): return m -class UserSecret(UserSecretBase): - def __init__(self, m=None): - super().__init__(m) - - -class GroupByRelationBase(Relation): +class GroupByRelationBase: def __init__(self, m=None): import tercen.model.impl as impl - if ("Relation", impl.Relation) in inspect.getmembers(impl): - GroupByRelationBase.__bases__ = (impl.Relation,) + GroupByRelationBase.__bases__ = (impl.Relation,) if m is None: super().__init__(m) self.group = list() - self.relation = Relation() + self.relation = impl.Relation() else: self.fromJson(m) def fromJson(self, m): + import tercen.model.impl as impl super().fromJson(m) self.subKind = m.get(Vocabulary.SUBKIND) if self.subKind is None and m.get(Vocabulary.KIND) != Vocabulary.GroupByRelation_CLASS: @@ -12008,16 +11167,17 @@ def fromJson(self, m): else: self.group = m[Vocabulary.group_DP] if m.get(Vocabulary.relation_OP) is None: - self.relation = Relation() + self.relation = impl.Relation() else: self.relation = RelationBase.createFromJson( m.get(Vocabulary.relation_OP)) @classmethod def createFromJson(cls, m): + import tercen.model.impl as impl kind = m.get(Vocabulary.KIND) if kind == Vocabulary.GroupByRelation_CLASS: - return GroupByRelation(m) + return impl.GroupByRelation(m) raise ValueError("bad kind : " + kind + " for class GroupByRelation in createFromJson") @@ -12031,8 +11191,3 @@ def toJson(self): m[Vocabulary.relation_OP] = self.relation if self.relation is None else self.relation.toJson() m[Vocabulary.group_DP] = self.group return m - - -class GroupByRelation(GroupByRelationBase): - def __init__(self, m=None): - super().__init__(m) diff --git a/tercen/model/impl.py b/tercen/model/impl.py index 53c02b9..862f32f 100644 --- a/tercen/model/impl.py +++ b/tercen/model/impl.py @@ -1 +1,851 @@ -from tercen.model.base import * \ No newline at end of file +from tercen.base.BaseObject import BaseObject +from tercen.model.base import * + +class SciObject(BaseObject): + def __init__(self, m=None): + super().__init__(m) + +class IdObject(IdObjectBase): + def __init__(self, m=None): + super().__init__(m) + +class PersistentObject(PersistentObjectBase): + def __init__(self, m=None): + super().__init__(m) + +class Document(DocumentBase): + def __init__(self, m=None): + super().__init__(m) + +class User(UserBase): + def __init__(self, m=None): + super().__init__(m) + +class Team(TeamBase): + def __init__(self, m=None): + super().__init__(m) + +class Property(PropertyBase): + def __init__(self, m=None): + super().__init__(m) + +class DoubleProperty(DoublePropertyBase): + def __init__(self, m=None): + super().__init__(m) + +class Rectangle(RectangleBase): + def __init__(self, m=None): + super().__init__(m) + +class State(StateBase): + def __init__(self, m=None): + super().__init__(m) + +class RunningState(RunningStateBase): + def __init__(self, m=None): + super().__init__(m) + +class Relation(RelationBase): + def __init__(self, m=None): + super().__init__(m) + +class WhereRelation(WhereRelationBase): + def __init__(self, m=None): + super().__init__(m) + +class Profile(ProfileBase): + def __init__(self, m=None): + super().__init__(m) + +class StorageProfile(StorageProfileBase): + def __init__(self, m=None): + super().__init__(m) + +class ResourceSummary(ResourceSummaryBase): + def __init__(self, m=None): + super().__init__(m) + +class BillingInfo(BillingInfoBase): + def __init__(self, m=None): + super().__init__(m) + +class Event(EventBase): + def __init__(self, m=None): + super().__init__(m) + +class PatchRecords(PatchRecordsBase): + def __init__(self, m=None): + super().__init__(m) + +class GarbageObject(GarbageObjectBase): + def __init__(self, m=None): + super().__init__(m) + +class GarbageTasks(GarbageTasksBase): + def __init__(self, m=None): + super().__init__(m) + +class Version(VersionBase): + def __init__(self, m=None): + super().__init__(m) + +class Filters(FiltersBase): + def __init__(self, m=None): + super().__init__(m) + +class Chart(ChartBase): + def __init__(self, m=None): + super().__init__(m) + +class ChartHeatmap(ChartHeatmapBase): + def __init__(self, m=None): + super().__init__(m) + +class StatisticNode(BaseObject): + def __init__(self, m=None): + super().__init__(m) + +class CubeQuery(CubeQueryBase): + def __init__(self, m=None): + super().__init__(m) + +class RLibrary(RLibraryBase): + def __init__(self, m=None): + super().__init__(m) + +class FilterTopExpr(FilterTopExprBase): + def __init__(self, m=None): + super().__init__(m) + +class Filter(FilterBase): + def __init__(self, m=None): + super().__init__(m) + +class Step(StepBase): + def __init__(self, m=None): + super().__init__(m) + +class ModelStep(ModelStepBase): + def __init__(self, m=None): + super().__init__(m) + +class RelationStep(RelationStepBase): + def __init__(self, m=None): + super().__init__(m) + +class GroupStep(GroupStepBase): + def __init__(self, m=None): + super().__init__(m) + +class TaskEvent(TaskEventBase): + def __init__(self, m=None): + super().__init__(m) + +class TaskLogEvent(TaskLogEventBase): + def __init__(self, m=None): + super().__init__(m) + +class UserSession(UserSessionBase): + def __init__(self, m=None): + super().__init__(m) + +class Table(TableBase): + def __init__(self, m=None): + super().__init__(m) + +class Operator(OperatorBase): + def __init__(self, m=None): + super().__init__(m) + +class GitOperator(GitOperatorBase): + def __init__(self, m=None): + super().__init__(m) + +class DockerOperator(DockerOperatorBase): + def __init__(self, m=None): + super().__init__(m) + +class Acl(AclBase): + def __init__(self, m=None): + super().__init__(m) + +class CubeAxisQuery(BaseObject): + def __init__(self, m=None): + super().__init__(m) + +class GateNode(GateNodeBase): + def __init__(self, m=None): + super().__init__(m) + +class TaskSummary(TaskSummaryBase): + def __init__(self, m=None): + super().__init__(m) + +class Palette(PaletteBase): + def __init__(self, m=None): + super().__init__(m) + +class RampPalette(RampPaletteBase): + def __init__(self, m=None): + super().__init__(m) + +class DistinctRelation(DistinctRelationBase): + def __init__(self, m=None): + super().__init__(m) + +class RunningDependentState(RunningDependentStateBase): + def __init__(self, m=None): + super().__init__(m) + +class Task(TaskBase): + def __init__(self, m=None): + super().__init__(m) + +class ProjectTask(ProjectTaskBase): + def __init__(self, m=None): + super().__init__(m) + +class ExportWorkflowTask(ExportWorkflowTaskBase): + def __init__(self, m=None): + super().__init__(m) + +class StartProcess(StartProcessBase): + def __init__(self, m=None): + super().__init__(m) + +class Token(TokenBase): + def __init__(self, m=None): + super().__init__(m) + +class ActivityCount(BaseObject): + def __init__(self, m=None): + super().__init__(m) + +class JoinOperator(JoinOperatorBase): + def __init__(self, m=None): + super().__init__(m) + +class OperatorModel(OperatorModelBase): + def __init__(self, m=None): + super().__init__(m) + +class FileMetadata(FileMetadataBase): + def __init__(self, m=None): + super().__init__(m) + +class CSVFileMetadata(CSVFileMetadataBase): + def __init__(self, m=None): + super().__init__(m) + +class StepModel(StepModelBase): + def __init__(self, m=None): + super().__init__(m) + +class TableStepModel(TableStepModelBase): + def __init__(self, m=None): + super().__init__(m) + +class NamespaceStep(NamespaceStepBase): + def __init__(self, m=None): + super().__init__(m) + +class MeltStep(MeltStepBase): + def __init__(self, m=None): + super().__init__(m) + +class CrosstabTable(CrosstabTableBase): + def __init__(self, m=None): + super().__init__(m) + +class XYAxisList(XYAxisListBase): + def __init__(self, m=None): + super().__init__(m) + +class ColorElement(ColorElementBase): + def __init__(self, m=None): + super().__init__(m) + +class DoubleColorElement(DoubleColorElementBase): + def __init__(self, m=None): + super().__init__(m) + +class TaskProgressEvent(TaskProgressEventBase): + def __init__(self, m=None): + super().__init__(m) + +class Crosstab(CrosstabBase): + def __init__(self, m=None): + super().__init__(m) + +class ProjectDocument(ProjectDocumentBase): + def __init__(self, m=None): + super().__init__(m) + +class Issue(IssueBase): + def __init__(self, m=None): + super().__init__(m) + +class PatchRecord(PatchRecordBase): + def __init__(self, m=None): + super().__init__(m) + +class CubeQueryTask(CubeQueryTaskBase): + def __init__(self, m=None): + super().__init__(m) + +class ComputationTask(ComputationTaskBase): + def __init__(self, m=None): + super().__init__(m) + +class SaveComputationResultTask(SaveComputationResultTaskBase): + def __init__(self, m=None): + super().__init__(m) + +class RunComputationTask(RunComputationTaskBase): + def __init__(self, m=None): + super().__init__(m) + +class WorkerEndpoint(WorkerEndpointBase): + def __init__(self, m=None): + super().__init__(m) + +class ColumnSchemaMetaData(ColumnSchemaMetaDataBase): + def __init__(self, m=None): + super().__init__(m) + +class Privilege(PrivilegeBase): + def __init__(self, m=None): + super().__init__(m) + +class CSVTask(CSVTaskBase): + def __init__(self, m=None): + super().__init__(m) + +class Activity(ActivityBase): + def __init__(self, m=None): + super().__init__(m) + +class ViesInfo(ViesInfoBase): + def __init__(self, m=None): + super().__init__(m) + +class JoinStepModel(JoinStepModelBase): + def __init__(self, m=None): + super().__init__(m) + +class Ulimits(BaseObject): + def __init__(self, m=None): + super().__init__(m) + +class RDescription(RDescriptionBase): + def __init__(self, m=None): + super().__init__(m) + +class JetPalette(JetPaletteBase): + def __init__(self, m=None): + super().__init__(m) + +class SimpleRelation(SimpleRelationBase): + def __init__(self, m=None): + super().__init__(m) + +class TableRelation(TableRelationBase): + def __init__(self, m=None): + super().__init__(m) + +class Date(DateBase): + def __init__(self, m=None): + super().__init__(m) + +class StepState(StepStateBase): + def __init__(self, m=None): + super().__init__(m) + +class OperatorResult(OperatorResultBase): + def __init__(self, m=None): + super().__init__(m) + +class RSourceLibrary(RSourceLibraryBase): + def __init__(self, m=None): + super().__init__(m) + +class FileDocument(FileDocumentBase): + def __init__(self, m=None): + super().__init__(m) + +class Address(AddressBase): + def __init__(self, m=None): + super().__init__(m) + +class TaskDataEvent(TaskDataEventBase): + def __init__(self, m=None): + super().__init__(m) + +class StringProperty(StringPropertyBase): + def __init__(self, m=None): + super().__init__(m) + +class XYAxis(XYAxisBase): + def __init__(self, m=None): + super().__init__(m) + +class Principal(PrincipalBase): + def __init__(self, m=None): + super().__init__(m) + +class Factor(FactorBase): + def __init__(self, m=None): + super().__init__(m) + +class Attribute(AttributeBase): + def __init__(self, m=None): + super().__init__(m) + +class ImportWorkflowTask(ImportWorkflowTaskBase): + def __init__(self, m=None): + super().__init__(m) + +class Project(ProjectBase): + def __init__(self, m=None): + super().__init__(m) + +class Url(UrlBase): + def __init__(self, m=None): + super().__init__(m) + +class StringColorElement(StringColorElementBase): + def __init__(self, m=None): + super().__init__(m) + +class EnumeratedProperty(EnumeratedPropertyBase): + def __init__(self, m=None): + super().__init__(m) + +class TestOperatorTask(TestOperatorTaskBase): + def __init__(self, m=None): + super().__init__(m) + +class ImportGitWorkflowTask(ImportGitWorkflowTaskBase): + def __init__(self, m=None): + super().__init__(m) + +class ReferenceRelation(ReferenceRelationBase): + def __init__(self, m=None): + super().__init__(m) + +class RProxy(RProxyBase): + def __init__(self, m=None): + super().__init__(m) + +class Pair(PairBase): + def __init__(self, m=None): + super().__init__(m) + +class InMemoryRelation(InMemoryRelationBase): + def __init__(self, m=None): + super().__init__(m) + +class RunProfile(RunProfileBase): + def __init__(self, m=None): + super().__init__(m) + +class CpuTimeProfile(CpuTimeProfileBase): + def __init__(self, m=None): + super().__init__(m) + +class AxisSettings(BaseObject): + def __init__(self, m=None): + super().__init__(m) + +class MappingFilter(BaseObject): + def __init__(self, m=None): + super().__init__(m) + +class ChartBar(ChartBarBase): + def __init__(self, m=None): + super().__init__(m) + +class FolderDocument(FolderDocumentBase): + def __init__(self, m=None): + super().__init__(m) + +class Lock(LockBase): + def __init__(self, m=None): + super().__init__(m) + +class Worker(WorkerBase): + def __init__(self, m=None): + super().__init__(m) + +class ImportGitDatasetTask(ImportGitDatasetTaskBase): + def __init__(self, m=None): + super().__init__(m) + +class Ace(AceBase): + def __init__(self, m=None): + super().__init__(m) + +class InStep(InStepBase): + def __init__(self, m=None): + super().__init__(m) + +class Labels(LabelsBase): + def __init__(self, m=None): + super().__init__(m) + +class RenvInstalledLibrary(RenvInstalledLibraryBase): + def __init__(self, m=None): + super().__init__(m) + +class OperatorSettings(OperatorSettingsBase): + def __init__(self, m=None): + super().__init__(m) + +class Schema(SchemaBase): + def __init__(self, m=None): + super().__init__(m) + +class CubeQueryTableSchema(CubeQueryTableSchemaBase): + def __init__(self, m=None): + super().__init__(m) + +class CategoryPalette(CategoryPaletteBase): + def __init__(self, m=None): + super().__init__(m) + +class TableSummary(TableSummaryBase): + def __init__(self, m=None): + super().__init__(m) + +class Point(PointBase): + def __init__(self, m=None): + super().__init__(m) + +class ColumnSchema(ColumnSchemaBase): + def __init__(self, m=None): + super().__init__(m) + +class Column(ColumnBase): + def __init__(self, m=None): + super().__init__(m) + +class Summary(SummaryBase): + def __init__(self, m=None): + super().__init__(m) + +class TaskStateEvent(TaskStateEventBase): + def __init__(self, m=None): + super().__init__(m) + +class WebAppOperator(WebAppOperatorBase): + def __init__(self, m=None): + super().__init__(m) + +class ShinyOperator(ShinyOperatorBase): + def __init__(self, m=None): + super().__init__(m) + +class Errors(ErrorsBase): + def __init__(self, m=None): + super().__init__(m) + +class GlTask(GlTaskBase): + def __init__(self, m=None): + super().__init__(m) + +class FailedState(FailedStateBase): + def __init__(self, m=None): + super().__init__(m) + +class CanceledState(CanceledStateBase): + def __init__(self, m=None): + super().__init__(m) + +class RunWorkflowTask(RunWorkflowTaskBase): + def __init__(self, m=None): + super().__init__(m) + +class GraphicalFactor(GraphicalFactorBase): + def __init__(self, m=None): + super().__init__(m) + +class RenameRelation(RenameRelationBase): + def __init__(self, m=None): + super().__init__(m) + +class ChartSize(ChartSizeBase): + def __init__(self, m=None): + super().__init__(m) + +class ChartLine(ChartLineBase): + def __init__(self, m=None): + super().__init__(m) + +class ColorList(ColorListBase): + def __init__(self, m=None): + super().__init__(m) + +class CrossTabStep(CrossTabStepBase): + def __init__(self, m=None): + super().__init__(m) + +class DataStep(DataStepBase): + def __init__(self, m=None): + super().__init__(m) + +class SearchResult(SearchResultBase): + def __init__(self, m=None): + super().__init__(m) + +class GateOperatorModel(GateOperatorModelBase): + def __init__(self, m=None): + super().__init__(m) + +class AnnotationModel(AnnotationModelBase): + def __init__(self, m=None): + super().__init__(m) + +class ROperator(ROperatorBase): + def __init__(self, m=None): + super().__init__(m) + +class OutStep(OutStepBase): + def __init__(self, m=None): + super().__init__(m) + +class LibraryTask(LibraryTaskBase): + def __init__(self, m=None): + super().__init__(m) + +class PreProcessor(PreProcessorBase): + def __init__(self, m=None): + super().__init__(m) + +class Port(PortBase): + def __init__(self, m=None): + super().__init__(m) + +class InputPort(InputPortBase): + def __init__(self, m=None): + super().__init__(m) + +class Properties(PropertiesBase): + def __init__(self, m=None): + super().__init__(m) + +class PropertyValue(PropertyValueBase): + def __init__(self, m=None): + super().__init__(m) + +class DoneState(DoneStateBase): + def __init__(self, m=None): + super().__init__(m) + +class AclContext(AclContextBase): + def __init__(self, m=None): + super().__init__(m) + +class DockerWebAppOperator(DockerWebAppOperatorBase): + def __init__(self, m=None): + super().__init__(m) + +class OperatorUnitTest(OperatorUnitTestBase): + def __init__(self, m=None): + super().__init__(m) + +class TableStep(TableStepBase): + def __init__(self, m=None): + super().__init__(m) + +class RunWebAppTask(RunWebAppTaskBase): + def __init__(self, m=None): + super().__init__(m) + +class UnionRelation(UnionRelationBase): + def __init__(self, m=None): + super().__init__(m) + +class Profiles(ProfilesBase): + def __init__(self, m=None): + super().__init__(m) + +class FilterExpr(FilterExprBase): + def __init__(self, m=None): + super().__init__(m) + +class FilterExpr2d(FilterExpr2dBase): + def __init__(self, m=None): + super().__init__(m) + +class FactorsProperty(FactorsPropertyBase): + def __init__(self, m=None): + super().__init__(m) + +class OperatorRef(OperatorRefBase): + def __init__(self, m=None): + super().__init__(m) + +class JoinStep(JoinStepBase): + def __init__(self, m=None): + super().__init__(m) + +class WizardStep(WizardStepBase): + def __init__(self, m=None): + super().__init__(m) + +class WizardStepModel(WizardStepModelBase): + def __init__(self, m=None): + super().__init__(m) + +class InitState(InitStateBase): + def __init__(self, m=None): + super().__init__(m) + +class PendingState(PendingStateBase): + def __init__(self, m=None): + super().__init__(m) + +class ChartPoint(ChartPointBase): + def __init__(self, m=None): + super().__init__(m) + +class ColumnPair(ColumnPairBase): + def __init__(self, m=None): + super().__init__(m) + +class CreateGitOperatorTask(CreateGitOperatorTaskBase): + def __init__(self, m=None): + super().__init__(m) + +class TaxId(TaxIdBase): + def __init__(self, m=None): + super().__init__(m) + +class IssueMessage(IssueMessageBase): + def __init__(self, m=None): + super().__init__(m) + +class TableSchema(TableSchemaBase): + def __init__(self, m=None): + super().__init__(m) + +class Plan(PlanBase): + def __init__(self, m=None): + super().__init__(m) + +class CSVParserParam(CSVParserParamBase): + def __init__(self, m=None): + super().__init__(m) + +class ExportTableTask(ExportTableTaskBase): + def __init__(self, m=None): + super().__init__(m) + +class GenericEvent(GenericEventBase): + def __init__(self, m=None): + super().__init__(m) + +class OutputPort(OutputPortBase): + def __init__(self, m=None): + super().__init__(m) + +class Link(LinkBase): + def __init__(self, m=None): + super().__init__(m) + +class AppDesign(AppDesignBase): + def __init__(self, m=None): + super().__init__(m) + +class GarbageTasks2(GarbageTasks2Base): + def __init__(self, m=None): + super().__init__(m) + +class Workflow(WorkflowBase): + def __init__(self, m=None): + super().__init__(m) + +class NamedFilter(NamedFilterBase): + def __init__(self, m=None): + super().__init__(m) + +class TableProfile(TableProfileBase): + def __init__(self, m=None): + super().__init__(m) + +class MeltStepModel(MeltStepModelBase): + def __init__(self, m=None): + super().__init__(m) + +class ExportModel(ExportModelBase): + def __init__(self, m=None): + super().__init__(m) + +class AnnotationOperatorModel(AnnotationOperatorModelBase): + def __init__(self, m=None): + super().__init__(m) + +class Axis(AxisBase): + def __init__(self, m=None): + super().__init__(m) + +class BooleanProperty(BooleanPropertyBase): + def __init__(self, m=None): + super().__init__(m) + +class GatherRelation(GatherRelationBase): + def __init__(self, m=None): + super().__init__(m) + +class ExportStep(ExportStepBase): + def __init__(self, m=None): + super().__init__(m) + +class ViewStep(ViewStepBase): + def __init__(self, m=None): + super().__init__(m) + +class ApiCallProfile(ApiCallProfileBase): + def __init__(self, m=None): + super().__init__(m) + +class Colors(ColorsBase): + def __init__(self, m=None): + super().__init__(m) + +class CompositeRelation(CompositeRelationBase): + def __init__(self, m=None): + super().__init__(m) + +class GitProjectTask(GitProjectTaskBase): + def __init__(self, m=None): + super().__init__(m) + +class ComputedTableSchema(ComputedTableSchemaBase): + def __init__(self, m=None): + super().__init__(m) + +class TableProperties(TablePropertiesBase): + def __init__(self, m=None): + super().__init__(m) + +class MappingFactor(MappingFactorBase): + def __init__(self, m=None): + super().__init__(m) + +class SubscriptionPlan(SubscriptionPlanBase): + def __init__(self, m=None): + super().__init__(m) + +class FormulaProperty(FormulaPropertyBase): + def __init__(self, m=None): + super().__init__(m) + +class UserSecret(UserSecretBase): + def __init__(self, m=None): + super().__init__(m) + +class GroupByRelation(GroupByRelationBase): + def __init__(self, m=None): + super().__init__(m) +