Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Release ELK with support of OWL API 5 #48

Open
matentzn opened this issue Jan 22, 2018 · 78 comments
Open

Release ELK with support of OWL API 5 #48

matentzn opened this issue Jan 22, 2018 · 78 comments

Comments

@matentzn
Copy link

matentzn commented Jan 22, 2018

I am not sure whether it is a bad on my end, but is there an integration of ELK with OWL API 5 yet? ELK 0.5 still seems to depend on an oldish version of OWLAPI 4 (the snapshot integrated via MAVEN).

@ykazakov
Copy link
Member

Duplicate of #45

@ykazakov ykazakov marked this as a duplicate of #45 Jan 22, 2018
@ykazakov
Copy link
Member

@matentzn can you give a bit more details about what is on your end? How do you use ELK from maven? What does not work?

ELK uses the OWL API 4 dependency (at the moment v. 4.2.7), that does not however mean it should not work with other versions of OWL API. In this regards, it is no different to any other kind of transitive maven dependencies.

@matentzn
Copy link
Author

I tried using it with 5, but there are some missing methods in 5 your code is referencing. OWLAPI 4 and 5 are not fully downwards compatible.

In a fresh project importing ELK 0.5 snapshot and OWL API 5.1.4, instantiate ELK in this way:

OWLOntology o = OWLManager.createOWLOntologyManager().loadOntologyFromOntologyDocument(IRI.create("https://raw.githubusercontent.com/obophenotype/upheno/master/imports/hsapdv_import.owl")); OWLReasoner r = new ElkReasonerFactory().createReasoner(o); System.out.println(r.isConsistent());

The following exception will be thrown:
Exception in thread "main" java.lang.NoSuchMethodError: org.semanticweb.owlapi.model.OWLTransitiveObjectPropertyAxiom.getProperty()Lorg/semanticweb/owlapi/model/OWLPropertyExpression; at org.semanticweb.elk.owlapi.wrapper.ElkTransitiveObjectPropertyAxiomWrap.getProperty(ElkTransitiveObjectPropertyAxiomWrap.java:52) at org.semanticweb.elk.owlapi.wrapper.ElkTransitiveObjectPropertyAxiomWrap.getProperty(ElkTransitiveObjectPropertyAxiomWrap.java:41) at org.semanticweb.elk.reasoner.indexing.conversion.ElkAxiomConverterImpl.visit(ElkAxiomConverterImpl.java:358) at org.semanticweb.elk.reasoner.indexing.conversion.ElkAxiomConverterImpl.visit(ElkAxiomConverterImpl.java:90) at org.semanticweb.elk.reasoner.indexing.classes.DelegatingElkAxiomVisitor.visit(DelegatingElkAxiomVisitor.java:243) at org.semanticweb.elk.reasoner.indexing.classes.NonIncrementalElkAxiomVisitor.visit(NonIncrementalElkAxiomVisitor.java:78) at org.semanticweb.elk.reasoner.indexing.classes.NonIncrementalElkAxiomVisitor.visit(NonIncrementalElkAxiomVisitor.java:46) at org.semanticweb.elk.owlapi.wrapper.ElkTransitiveObjectPropertyAxiomWrap.accept(ElkTransitiveObjectPropertyAxiomWrap.java:67) at org.semanticweb.elk.owlapi.wrapper.ElkTransitiveObjectPropertyAxiomWrap.accept(ElkTransitiveObjectPropertyAxiomWrap.java:57) at org.semanticweb.elk.owlapi.wrapper.ElkObjectPropertyAxiomWrap.accept(ElkObjectPropertyAxiomWrap.java:48) at org.semanticweb.elk.reasoner.indexing.classes.ChangeIndexingProcessor.visit(ChangeIndexingProcessor.java:73) at org.semanticweb.elk.owlapi.OwlOntologyLoader.load(OwlOntologyLoader.java:136) at org.semanticweb.elk.reasoner.stages.InputLoadingStage.executeStage(InputLoadingStage.java:228) at org.semanticweb.elk.reasoner.stages.AbstractReasonerStage.execute(AbstractReasonerStage.java:148) at org.semanticweb.elk.reasoner.stages.InputLoadingStage.execute(InputLoadingStage.java:70) at org.semanticweb.elk.reasoner.stages.LoggingStageExecutor.execute(LoggingStageExecutor.java:52) at org.semanticweb.elk.reasoner.stages.AbstractStageExecutor.complete(AbstractStageExecutor.java:46) at org.semanticweb.elk.reasoner.stages.AbstractReasonerState.complete(AbstractReasonerState.java:225) at org.semanticweb.elk.reasoner.stages.AbstractReasonerState.ensureLoading(AbstractReasonerState.java:369) at org.semanticweb.elk.reasoner.stages.AbstractReasonerState.restoreSaturation(AbstractReasonerState.java:381) at org.semanticweb.elk.reasoner.stages.AbstractReasonerState.isInconsistent(AbstractReasonerState.java:468) at org.semanticweb.elk.owlapi.ElkReasoner.isConsistent(ElkReasoner.java:954) at RunELK.main(RunELK.java:14)

@matentzn
Copy link
Author

For now I downgraded my codebase to OA4, because I really need ELK.. Would be cool if someone could take care of that one day, because I really like using the OA5 streams.

@ykazakov
Copy link
Member

ykazakov commented Jan 22, 2018

You code works fine for me with OWL API 5.1.4 and ELK 0.5.0-SNAPSHOT and returnstrue.
Here is my pom.xml:

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>

	<groupId>org.liveontologies</groupId>
	<artifactId>elk-owlapi5-tryout</artifactId>
	<version>0.0.1-SNAPSHOT</version>

	<dependencies>
		<dependency>
			<groupId>org.semanticweb.elk</groupId>
			<artifactId>elk-owlapi</artifactId>
			<version>0.5.0-SNAPSHOT</version>
		</dependency>
		<dependency>
			<groupId>net.sourceforge.owlapi</groupId>
			<artifactId>owlapi-distribution</artifactId>
			<version>5.1.4</version>
		</dependency>
	</dependencies>

	<repositories>
		<repository>
			<!-- the repository for snapshot dependencies -->
			<id>ossrh</id>
			<url>https://oss.sonatype.org/content/repositories/snapshots</url>
			<snapshots>
				<enabled>true</enabled>
			</snapshots>
			<releases>
				<enabled>false</enabled>
			</releases>
		</repository>
	</repositories>

</project>

Also, OWL API 5.1.4 has the method org.semanticweb.owlapi.model.OWLTransitiveObjectPropertyAxiom.getProperty()Lorg/semanticweb/owlapi/model/OWLPropertyExpression, which can be tested using this code:

OWLDataFactory f = OWLManager.getOWLDataFactory();
		OWLObjectProperty t = f
				.getOWLObjectProperty(IRI.create("http://test.org/t"));
		OWLTransitiveObjectPropertyAxiom ax = f
				.getOWLTransitiveObjectPropertyAxiom(t);
		System.out.println(ax.getProperty());

@matentzn
Copy link
Author

matentzn commented Jan 23, 2018

Hmm. I must be missing something crucial. I looked at the specs and you are right, getProperty() can be found in a super interface of the one in question. But the exception is still thrown. Can you try to explicitly exclude OA4?

`<project ...>
4.0.0

<groupId>nico</groupId>
<artifactId>tets</artifactId>
<version>1.0-SNAPSHOT</version>


<properties>
    <java.version>1.8</java.version>
</properties>

<dependencies>
    <!-- https://mvnrepository.com/artifact/net.sourceforge.owlapi/owlapi-distribution -->
    <dependency>
        <groupId>org.semanticweb.elk</groupId>
        <artifactId>elk-owlapi</artifactId>
        <version>0.5.0-SNAPSHOT</version>
        <exclusions>
            <exclusion>
                <groupId>net.sourceforge.owlapi</groupId>
                <artifactId>owlapi-api</artifactId>
            </exclusion>
            <exclusion>
                <groupId>net.sourceforge.owlapi</groupId>
                <artifactId>owlapi-impl</artifactId>
            </exclusion>
            <exclusion>
                <groupId>net.sourceforge.owlapi</groupId>
                <artifactId>owlapi-apibinding</artifactId>
            </exclusion>
        </exclusions>
    </dependency>
   <dependency>
        <groupId>net.sourceforge.owlapi</groupId>
        <artifactId>owlapi-distribution</artifactId>
        <version>5.1.4</version>
    </dependency>


</dependencies>
<repositories>
    <repository>
        <id>sonatype-nexus-snapshots</id>
        <url>https://oss.sonatype.org/content/repositories/snapshots/</url>
        <releases>
            <enabled>false</enabled>
        </releases>
        <snapshots>
            <enabled>true</enabled>
        </snapshots>
    </repository>
</repositories>
<build><plugins>
    <plugin>
        <artifactId>maven-compiler-plugin</artifactId>
        <configuration>
            <source>1.8</source>
            <target>1.8</target>
        </configuration>
    </plugin>
</plugins></build>

`

@ykazakov
Copy link
Member

You are right. It does not work this way. Something is messed up with the class loader. I'll investigate.

As a workaround, you can compile a version of ELK with OWL API 5 by activating the owlapi5 profile.

mvn clean install -Powlapi5

Then remove the sonatype repository from pom to prevent the current snapshot version being pulled (or rename the ELK version to something else).

@matentzn
Copy link
Author

Ok, cool. That works for now! Thanks. I would like to keep this issue open though until we have a owlapi 5 compatible release on Maven central.. If you dont mind!

@ykazakov
Copy link
Member

Interestingly, if I compile ELK with owapi5 but then use with your code in OWL API 4, then it works fine. Perhaps we can then switch to the OWL API 5 dependency by default, but then one needs to actually test that the produce jar works with v. 4 and there are no class loader problems like this.

@matentzn
Copy link
Author

I would not recommend that. The majority of projects I think still work on 4, and they should get that major release as well. I think you should consider that 4 and 5 are really not compatible. My humble view is that the community is served best with separate releases for OA4 and OA5, under different version numbers (perhaps 0.4.4 vs 0.5). It would also help with project setup not being messed up too much by wrong OA versions being imported and making it onto the classpath.. :) What do you think?

@ykazakov
Copy link
Member

What makes sure that a jar compiled with OA 5.1.x is compatible with OA 5.2.y and a jar for OA 4.5.x is compatible with OA 4.3.x? We cannot release a separate version of ELK for every possible (major or minor) version of OWL API. Otherwise, you will have to deal with the dependency mess anyway (e.g., exclude 4.5.1 dependency and include 4.5.4 when you use OA 4.5.4).

My idea was to avoid using APIs that have changed between the version, so that one jar works with all of them. But for some reason it doesn't.

@matentzn
Copy link
Author

As far as I understand, the current OA 4 and 5 releases are stable in terms of API.

@ignazio1977 Do you have any advice for this issue?

My feeling is that ELK is already, and will be, the one most important tool our domain uses for reasoning for years to come. A proper solution would be really desirable. (I am working for EBI now and they use ELK everywhere).

@ykazakov
Copy link
Member

Regarding stability of OWL API API, there is an interesting ticket: owlcs/owlapi#624

In general, the problem is not new or unique to ELK (there are tons of software that use different versions of common libraries, like guava, slf4j, apache-commons, and everything somehow works).
I think the solution in our case will be as before: we will gradually migrate to a new version of OWL API (like we already did already with 3 => 4), and those who stuck with an old version of OA should just use the older version of ELK.
At the moment the only issue stopping us from migrating to OA 5 is Protege. I did a quick test, and it seems though that ELK compiled with OA 5 works fine with P4. If it is really the case, then there is no brainer to switch to OA 5. Just need to find a way how to reliably test that the OA5-comiped jar works with OA 4.

@ignazio1977
Copy link

Regarding stability of OWL API API, there is an interesting ticket: owlcs/owlapi#624

Interesting indeed. The semantics of adding new methods to public classes (not interfaces) in terms of OSGi numbering are fascinating. Or maddening, depending. However, it is true that there will be no major changes to OWLAPI 5, as far as I can tell.

Re Protege, by the same coin ELK should be able to use OWLAPI 5 - if it starts properly, that means the OWLOntology and the OWLReasoner interfaces work well between Protege and ELK. I thought that's where things would fail, actually, as that's where the host app and the bundles interact. It's also the main obstacle in Protege development, I'm told - it's hard to sort all plugins to work on a new OWLAPI version.

@ignazio1977
Copy link

Regarding ELK and its importance in the community, definitely true - speaking of which, if there's any need for help in upgrading, please let me know.

@ykazakov
Copy link
Member

I think I have some explanation regarding the thrown java.lang.NoSuchMethodError
When I try to print the method getProperty() for OWLTransitiveObjectPropertyAxiom using the following code:

Class<?> cls = OWLTransitiveObjectPropertyAxiom.class;
Method method = cls.getMethod("getProperty", (Class<?>[]) null);
System.out.println(method);

For OWL API 4.5.1 this gives me:

public abstract org.semanticweb.owlapi.model.OWLPropertyExpression org.semanticweb.owlapi.model.OWLUnaryPropertyAxiom.getProperty()

For OWL API 5.1.4 I obtain:

public abstract org.semanticweb.owlapi.model.OWLObject org.semanticweb.owlapi.model.HasProperty.getProperty()

Notice the different return types: OWLObject instead of OWLPropertyExpression. Why? Because in OWL API 4 OWLUnaryPropertyAxiom overrides getProperty() from the generic super-interface HasProperty<P> to return OWLPropertyExpression (the smallest type of the generic parameter), but in OWL API 5 it is not overriden. So, when ELK is compiled against OWL API 4, in the byte code of ELK where the method OWLTransitiveObjectPropertyAxiom.getProperty() is invoked, it is written that the returned value should be of the type OWLPropertyExpression , and this is not the case for OWL API 5! Note that the generic parameters have no effect on the byte code!

Now it is also clear why the jar compiled with OWL API 5 works for OWL API 4, at least in this case: because the output type OWLObject of getProperty() compiled in the byte code is more general than OWLPropertyExpression present in the library. It is not clear whether this compatibility holds in other cases though, so further tests are necessary.

So to sum up: binary compatibility is a very tricky issue.

@ignazio1977
Copy link

Indeed, binary compatibility is hard. In order to properly get this to work (any version of a reasoner to work with any version of OWLAPI) I think the only possibility would be a separate API definition, e.g., the api module released as 1.0.0 and never changed afterwards. However that has its own drawbacks, obviously - we'd need to get it perfect the first time, or forever live with the mistakes. The alternative is incompatible changes between major versions, like in this case. Some are obvious (method name changes, new methods, old classes disappearing) other are subtle, like the one you spotted here, or like the incompatibility between an old version of Pellet and Java 7 (something to do with a new method with generic arguments in Map, if I remember correctly?)

What makes sure that a jar compiled with OA 5.1.x is compatible with OA 5.2.y and a jar for OA 4.5.x is compatible with OA 4.3.x?

5.2 is meant to be backwards compatible with 5.1, unless changes were required to fix bugs (same in general for all minor versions). I can't give a 100% guarantee, but that's the intent.

The second case is harder - a newer version might have acquired a new functionality that the client code uses, and the older version might not have it, and sometimes a bug fix might cause the same sort of problems.

@ykazakov
Copy link
Member

ykazakov commented Jan 25, 2018

FYI: here I found a small utility that can check compatibility of jars and compared owlapi-api-5.1.0.jar with owlapi-api-5.1.4.jar.

Here is the result:

Binary compatibility: 99.8%
Source compatibility: 96.8%

=> so not 100% compatible.

The full report can be seen here.

ykazakov added a commit that referenced this issue Mar 13, 2018
Make some fixes to ensure that ELK jar compiled with
OWL API 4.x works with OWL API 5.x
ykazakov added a commit that referenced this issue Mar 13, 2018
Address issue #48

new modules:
- elk-owlapi-parent now contains the ELK OWL API modules for
both OWL API version 4 and 5: elk-owlapi4, elk-owlapi5
- elk-distribution-parent now contains separate module for every
distribution type: elk-distribution-cli, elk-distribution-owlapi4,
elk-distribution-owlapi5, elk-distribution-protege

removed modules:
- elk-distribution (which has been replaced)
- elk-standalone (the ELK CLI standalone binary is now build in
elk-distribution-cli)
- elk-wolapi-standalone (the ELK OWL API jar package is now build in
elk-distribution-owlapi4 and elk-distribution-owlapi5)
@ykazakov
Copy link
Member

OK, ELK now supports both OWL API v. 4.x and v.5.x. To use, first add the snapshot repository:

<repositories>
   <repository>
      <id>sonatype-nexus-snapshots</id>
      <url>https://oss.sonatype.org/content/repositories/snapshots/</url>
      <releases>
         <enabled>false</enabled>
      </releases>
      <snapshots>
         <enabled>true</enabled>
      </snapshots>
   </repository>
</repositories>

For OWL API 4.x use this dependency:

<dependency> 
   <groupId>org.semanticweb.elk</groupId> 
   <artifactId>elk-owlapi4</artifactId> 
   <version>0.5.0-SNAPSHOT</version> 
</dependency> 

For OWL API 5.x use this dependency:

<dependency> 
   <groupId>org.semanticweb.elk</groupId> 
   <artifactId>elk-owlapi5</artifactId> 
   <version>0.5.0-SNAPSHOT</version> 
</dependency> 

Please test and report if there are any problems!

@matentzn
Copy link
Author

This is awesome! I tested both, and I did not have any problems so far. The getReasonerVersion bug is still there, but I will mention it in the appropriate place. This can be closed I think!

@reality
Copy link

reality commented Mar 26, 2018

Just a note for anyone who needs to get this working with Groovy, before the full version is released:

  @Grapes([                                                                                                                   
    @Grab(group='net.sourceforge.owlapi', module='owlapi-api', version='5.1.4'),
    @Grab(group='net.sourceforge.owlapi', module='owlapi-apibinding', version='5.1.4'),
    @Grab(group='net.sourceforge.owlapi', module='owlapi-impl', version='5.1.4'),
    @Grab(group='net.sourceforge.owlapi', module='owlapi-parsers', version='5.1.4'),
    @Grab(group='org.apache.commons', module='commons-rdf-api', version='0.5.0'),
 
   @GrabResolver(name='sonatype-nexus-snapshots', root='https://oss.sonatype.org/content/repositories/snapshots/'),
   @Grab(group='org.semanticweb.elk', module='elk-owlapi5', version='0.5.0-SNAPSHOT'),
  ])
`

@matentzn
Copy link
Author

Hey Yevgeny! As we have a couple of groups now relying on ELK, and the new Snapshot is really awesome, we would be very (!) thankful if you could do a proper Maven central/repository release. There are some issues here and there with inter maven dependencies when something is not actually hosted on one of the known maven repos. :) Greatest thanks, as always!

@ykazakov
Copy link
Member

I am waiting for the next release of Protege (and integration of my pull request protegeproject/protege#734). Without that, the ELK protege plugin does not display warnings properly. Also I wanted to finalise a few things before making the final 0.5 release. This will probably happen only at the end of July - August.
If you urgently need ELK from Maven central, or at least its OWL-API artefacts, I suggest to release them yourself. If you release them under your groupId, this should not confuse the users of "official" releases.

@matentzn
Copy link
Author

We can wait a bit :)! Thanks for letting me know. We might create our own release, and then replace it once you create an official one. Thank you!

@matentzn
Copy link
Author

Hey Yevgeny! Any update on our favourite reasoner? :P No, is, of course, fine. As you can see, it is already making waves in GO and UBERON, both of which could not be classified with ordinary OWL 2 reasoners, hence everyone used Elk 0.4.3. But because that was slightly incomplete in terms of axiom types, we get now a few nice issues such as:

which references the most exquisite:

@ykazakov
Copy link
Member

So it looks like ELK 0.5 can do more harm than good ;-)
Unfortunately, I did not have much time to work on ELK this summer. Now as semester has started this will be even more difficult. Perhaps I can release the current version to maven-central as 0.5-beta1 or something, perhaps in a few weeks.

@matentzn
Copy link
Author

Haha good luck with the semester then! Dont worry for now. The solution you already provided for us is fine in the intermediate time. I will ping you again in December! :)

@ykazakov
Copy link
Member

Which 0.5 dev? The unofficial release of au.csiro?

@matentzn
Copy link
Author

matentzn commented May 10, 2022 via email

@ykazakov
Copy link
Member

OK, could as well name it 0.6.

@matentzn
Copy link
Author

matentzn commented Jan 9, 2023

@ykazakov Happy New Year! Any updates on the Elk 0.6 release?

@ykazakov
Copy link
Member

ykazakov commented Jan 9, 2023

@matentzn Happy New Year! Yes, I should find some time to finish the ELK release. Will look at it ASAP.

@matentzn
Copy link
Author

matentzn commented Aug 5, 2023

@ykazakov Happy summer :) Hope all is well. Any chance for a.. release this year? Thank you! And i do understand: No time! No problem. Just checking in saying: we are still interested.

@ykazakov
Copy link
Member

FYI: I am planning to change the ELK version and groupId as follows:

<artifactId>elk-ore-parent</artifactId>
<groupId>com.github.liveontologies</groupId>
<version>5.0.0-SNAPSHOT</version>

The version is changed to use more version qualifiers. I think this is now a more modern approach. ;-)
The domain elk.semanticweb.org is no longer under our control, which could cause problems for deploying to maven central.

I hope these changed do not cause any confusion or disruption.

I hope to make a release soon, or at least restore the provision of snapshots from maven central.

@ykazakov ykazakov mentioned this issue Mar 27, 2024
@ykazakov
Copy link
Member

I have just re-enabled the snapshot repository. Please test and report if you encounter any problems!

@ykazakov ykazakov changed the title OWL API 5 Integration, Maven central and Protege plugin. Release ELK with support of OWL API 5 Mar 27, 2024
@matentzn
Copy link
Author

matentzn commented Apr 4, 2024

@ykazakov thank you!

Which changes can we expect in this new release? Is there a new release? Can you make some release notes?

Maybe make a proper Github release (even of a pre-release) so we see what to expect. https://github.com/liveontologies/elk-reasoner/releases :)

Then we will assign someone for testing! Thank you! Very exciting!

@reckart
Copy link

reckart commented Apr 7, 2024

Please post releases to Maven Central to facilitate actually using them.

@matentzn
Copy link
Author

matentzn commented May 1, 2024

Hello @ykazakov! We are thinking of updating all our stacks to the new Elk version, but its a bit inconvenient to do it from the snapshot repo without proper versioning. Are there any plans to create a proper Maven release or do you prefer someone else to do it? Also, can we get a list of changes you did for the new version to estimate the impact on our 100 ontologies using Elk during builds?

@ykazakov
Copy link
Member

ykazakov commented May 2, 2024

Hi @matentzn! By all means feel free to create a fork and make the release! Who knows when I have time to work on this again. Particularly, describing all changes made for the last 8 years is not done in an instant. Do you know any automated tool that generates release logs from commits? Also, not sure how would it help to estimate the impact on ontologies - you probably use tons of non-EL features and changes in unsupported cases like #61 would not be described in release log anyway.

@reckart
Copy link

reckart commented May 2, 2024

Do you know any automated tool that generates release logs from commits?

git log v0.4.3..master --pretty=format:"%s (by %an)" --abbrev-commit | sort | uniq

What is nicer though is for projects that consistently use pull requests for all changes, GitHub has a nice feature for auto-generating a changes report from the PRs. You can find that here and then go on to draft a new release.

@matentzn
Copy link
Author

matentzn commented May 3, 2024

I agree with @reckart very much :) Thanks @reckart! I would very much endorse doing a github release now so we all know the version we are on.

@ykazakov if you like, you can make me a co-owner of this repo and I can do such releases. We can have an understanding that I am not allowed to merge any functional changes to the repo, but having the official ELK repo being "community-driven" would help us immensely while we are evolving our technology stacks.

Also, we are having some internal debates how to interpret your new version 5.0.0 - I thought we were in 0.5.0, so I would have thought your new release should be 0.6.0. Can you confirm that?

@ykazakov
Copy link
Member

ykazakov commented May 3, 2024

Thanks @reckart, the git command indeed produces a usable draft. Of course, the list of changes is too long (and a bit cryptic) for release notes.
Generating the GitHub report, however, does not work as we did not use any PRs.

@matentzn doing a (maven) release should not take much time. Everything should be already configured. In principle, I could do a release from the current version on the GitHub in one day.

The main problem is to sort the remaining things out. Like the dependency mess caused by the outdated version of Protege (the old versions of Guava and log4j have security vulnerabilities, which you probably do not want to pull together with ELK). I was in a process of fixing these problems, but I had to interrupt. There is also some code in other branches which needs to be merged. I think there is also one snapshot-dependency which should be also released (or removed) for a maven release.

Regarding the version number, as mentioned above, being able to use all qualifiers gives more flexibility in choosing versions. I thought you wanted to differentiate from version 0.5.0, which the version 5.0.0 also does. However, if you prefer version 0.6.0, I am also fine with that.

How about the following proposal: I make a release of whatever is currently in git under a pre-release version like 0.6.0-rc1, without writing release notes. Would it work for you?

@matentzn
Copy link
Author

matentzn commented May 3, 2024

How about the following proposal: I make a release of whatever is currently in git under a pre-release version like 0.6.0-rc1, without writing release notes. Would it work for you?

Ok! Thank you!

It would be great if we could get this soon. Can we also create a Github tag with the exact same release version so we can make diffs and comparisons in the future?

@balhoff
Copy link

balhoff commented May 3, 2024

@ykazakov if you can make a release that would be great! I had started looking at putting up a release under a different org, but if you are able to do it I think that would be even better.

@balhoff
Copy link

balhoff commented May 16, 2024

@ykazakov we have tested your 0.6-SNAPSHOT in Protege and ROBOT and it seems to fix the issues we had with 0.5. Thanks for making that release! Is it possible to put the same release on Maven Central as 0.6.0, or as an RC?

@ykazakov
Copy link
Member

@balhoff Excellent! I decided to make a proper release (not RC). Currently fixing last problems. I hope I can publish to Maven Central this week. Will let you know!

@matentzn
Copy link
Author

Hey @ykazakov just to let you know the OBO community its holding its breath waiting for your release :P :

  1. Protege (https://github.com/protegeproject/protege)
  2. ROBOT (https://github.com/ontodev/robot)
  3. ODK (https://github.com/INCATools/ontology-development-kit)

(and probably more projects). Since we have thoroughly tested last weeks SNAPSHOT, can you tell us:

  1. ETA of the Maven Central release
  2. Where there any possibly breaking changes between last weeks snapshot and the upcoming Maven Central release?

@ykazakov
Copy link
Member

Hi @matentzn @balhoff I am very sorry for the delay. There have been a few last-minute issues that stopped me from making the release. The most significant one is that the plugins install via the Protege UI may only contain one jar. And ELK needs to use a shared library puli to provide proof-based explanations. This library cannot be provided just by the proof-explanation plugin since the reasoner should also work without this plugin. I have now (hopefully) fixed this problem by removing references to puli from the reasoning classes. Currently I finishing things up (updating the README etc), I hope I can do the release tomorrow, if nothing else pops up. I hope this answers your first question.

Regarding the breaking changes, I do not think there is any, but feel free to check how the latest snapshot is working for you. Note that the grouId has changed to io.github.liveontologies and the snapshot repository is now https://s01.oss.sonatype.org/content/repositories/snapshots. I am not keeping up with updating the wiki (will do that later after the release).

@ykazakov
Copy link
Member

So, I just released ELK 0.6 to maven central. I hope it should be available soon (if not already). I will publish the artifacts on github later.

@matentzn
Copy link
Author

Aweeesome! Thank you!

@balhoff
Copy link

balhoff commented May 27, 2024

Thanks @ykazakov!

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment
Labels
None yet
Projects
None yet
Development

No branches or pull requests

7 participants