sdispater / mixology Goto Github PK

View Code? Open in Web Editor NEW

79.0 6.0 11.0 64 KB

A generic dependency-resolution library written in pure Python

License: MIT License

Python 100.00%

python dependency-resolution

mixology's People

Contributors

Stargazers

Watchers

Forkers

chrahunt pombredanne ddelange awhetter eddiehoyle ohmybuggg stefanoborini rcox771 vinz178 battyone markush

mixology's Issues

Limit for 10 packages

mixology/mixology/version_solver.py

Lines 68 to 73 in 067c5ae

 i = 0 

 while not self.is_solved(): 

 if not self._run() or i > 10: 

 break 

 i += 1

Is it intended limit or some testing code left over?

PyPA is seeking for a paid contractor for dependency resolution

I just wanted to let you know that PyPA is looking for someone to do similar work.

This is paid (important) work.

In case you haven't heard about this, it's here: http://pyfound.blogspot.com/2019/11/seeking-developers-for-paid-contract.html

BTW, after having use poetry a little bit, I really like it.

Et puisque tu es visiblement français, sache que poetry me sert pour https://github.com/vpoulailleau/padpo qui sert à la traduction en français de la doc officielle de Python.

What's the best way to use install mixology - here or through poetry?

Hey, I noticed that Poetry has a mixology component https://github.com/python-poetry/poetry/tree/master/src/poetry/mixology that looks more up-to-date than this repo (last commit here was a couple of years ago, last commit to that link was a couple of weeks ago).

IIUC you (the maintainer of this project) are the creator of poetry. I'm wondering if you have any advice for me as I'm developing my own package manager for a different programming language and would like to incorporate the mixology and semver sub-packages from Poetry's codebase. Is there a way I can pip/conda install some parts of Poetry's backend to get the up-to-date versions or should I stick to these standalone repos for mixology and poetry-semver that are perfectly functional but no-longer updated?

Thanks, any thoughts much appreciated :) And thanks for open-sourcing this fantastic approach too.

Wrong indentation according to original code in poetry

mixology/mixology/incompatibility.py

Lines 70 to 81 in 067c5ae

 new_terms = [] 

 for by_ref in by_name.values(): 

 positive_terms = [ 

 term for term in by_ref.values() if term.is_positive() 

 ] 

 if positive_terms: 

 new_terms += positive_terms 

 continue 

 new_terms += list(by_ref.values()) 

 terms = new_terms

Bug in version solver when using a hashable object to represent a package, not just a string.

I believe it's this line:

mixology/mixology/version_solver.py

Line 130 in 067c5ae

changed.add(str(self._propagate_incompatibility(root_cause)))

self._propagate_incompatibility will return the _conflict type which is the hashable type used to represent a package (in my usecase this is not a string). The line converts it to str which is a problem since then it is no longer a valid key in the self._incompatibilities dictionary (line 113 of the same function).

mixology/mixology/version_solver.py

Lines 98 to 133 in 067c5ae

 def _propagate(self, package): # type: (Hashable) -> None 

 """ 

  Performs unit propagation on incompatibilities transitively 

  related to package to derive new assignments for _solution. 

  """ 

 changed = set() 

 changed.add(package) 

 while changed: 

 package = changed.pop() 

 # Iterate in reverse because conflict resolution tends to produce more 

 # general incompatibilities as time goes on. If we look at those first, 

 # we can derive stronger assignments sooner and more eagerly find 

 # conflicts. 

 for incompatibility in reversed(self._incompatibilities[package]): 

 result = self._propagate_incompatibility(incompatibility) 

 if result is _conflict: 

 # If the incompatibility is satisfied by the solution, we use 

 # _resolve_conflict() to determine the root cause of the conflict as a 

 # new incompatibility. 

 # 

 # It also backjumps to a point in the solution 

 # where that incompatibility will allow us to derive new assignments 

 # that avoid the conflict. 

 root_cause = self._resolve_conflict(incompatibility) 

 # Back jumping erases all the assignments we did at the previous 

 # decision level, so we clear [changed] and refill it with the 

 # newly-propagated assignment. 

 changed.clear() 

 changed.add(str(self._propagate_incompatibility(root_cause))) 

 break 

 elif result is not None: 

 changed.add(result)

Need help when port the PubGrub version solver into other language

Hi, @sdispater, thanks for your great work here!

I was confused when I read a piece of your code, see
https://github.com/sdispater/mixology/blob/master/mixology/incompatibility.py#L29
there you remove the root package from generated incompatibilities, since it will always be satisfied, but,

term.is_positive() and term.package != Package.root()

is there a typo here? I think it should be:

term.is_positive() and term.package == Package.root()

I do a double check by reading ruby port of the PubGrub version solver, see https://github.com/jhawthorn/pub_grub/blob/master/lib/pub_grub/incompatibility.rb#L121

Would you mind to make a check and explain? Thanks!

sdispater / mixology Goto Github PK

mixology's People

Contributors

Stargazers

Watchers

Forkers

mixology's Issues

Limit for 10 packages

PyPA is seeking for a paid contractor for dependency resolution

What's the best way to use install mixology - here or through poetry?

Wrong indentation according to original code in poetry

Bug in version solver when using a hashable object to represent a package, not just a string.

Need help when port the PubGrub version solver into other language

Recommend Projects

React

Vue.js

Typescript

TensorFlow

Django

Laravel

D3

Recommend Topics

javascript

web

server

Machine learning

Visualization

Game

Recommend Org

Facebook

Microsoft

Google

Alibaba

D3

Tencent

Jobs

	i = 0
	while not self.is_solved():
	if not self._run() or i > 10:
	break

	i += 1

	new_terms = []
	for by_ref in by_name.values():
	positive_terms = [
	term for term in by_ref.values() if term.is_positive()
	]
	if positive_terms:
	new_terms += positive_terms
	continue

	new_terms += list(by_ref.values())

	terms = new_terms

	def _propagate(self, package): # type: (Hashable) -> None
	"""
	Performs unit propagation on incompatibilities transitively
	related to package to derive new assignments for _solution.
	"""
	changed = set()
	changed.add(package)

	while changed:
	package = changed.pop()

	# Iterate in reverse because conflict resolution tends to produce more
	# general incompatibilities as time goes on. If we look at those first,
	# we can derive stronger assignments sooner and more eagerly find
	# conflicts.
	for incompatibility in reversed(self._incompatibilities[package]):
	result = self._propagate_incompatibility(incompatibility)

	if result is _conflict:
	# If the incompatibility is satisfied by the solution, we use
	# _resolve_conflict() to determine the root cause of the conflict as a
	# new incompatibility.
	#
	# It also backjumps to a point in the solution
	# where that incompatibility will allow us to derive new assignments
	# that avoid the conflict.
	root_cause = self._resolve_conflict(incompatibility)

	# Back jumping erases all the assignments we did at the previous
	# decision level, so we clear [changed] and refill it with the
	# newly-propagated assignment.
	changed.clear()
	changed.add(str(self._propagate_incompatibility(root_cause)))
	break
	elif result is not None:
	changed.add(result)