structures-detroix23 0.0.3__tar.gz

structures_detroix23-0.0.3/PKG-INFO

@@ -0,0 +1,24 @@
+Metadata-Version: 2.4
+Name: structures_detroix23
+Version: 0.0.3
+Summary: Python structures.
+Author-email: Detroix23 <detroix23@gmail.com>
+License-Expression: CC-BY-4.0
+Project-URL: Repository, https://github.com/Detroix23/py_structures
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Classifier: Natural Language :: English
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE.md
+Dynamic: license-file
+
+# Data structures.
+
+Classes:
+- Chained lists (algorithmically);
+- Stack;
+- Queue;
+- Doubly-chained lists;
+- Tree;
+- Graphs;

structures_detroix23-0.0.3/README.md

@@ -0,0 +1,9 @@
+# Data structures.
+
+Classes:
+- Chained lists (algorithmically);
+- Stack;
+- Queue;
+- Doubly-chained lists;
+- Tree;
+- Graphs;

structures_detroix23-0.0.3/pyproject.toml

@@ -0,0 +1,27 @@
+[project]
+name = "structures_detroix23"
+version = "0.0.3"
+description = "Python structures."
+authors = [
+    { name="Detroix23", email="detroix23@gmail.com" }
+]
+readme = "README.md"
+requires-python = ">=3.12"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Operating System :: OS Independent",
+    "Natural Language :: English",
+]
+dependencies = [
+]
+license = "CC-BY-4.0"
+license-files = [
+    "LICENSE.md"
+]
+
+[project.urls]
+Repository = "https://github.com/Detroix23/py_structures"
+
+[build-system]
+requires = ["setuptools"]
+build-backend = "setuptools.build_meta"

structures_detroix23-0.0.3/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

structures_detroix23-0.0.3/src/structures_detroix23/__init__.py

@@ -0,0 +1,15 @@
+# type: ignore
+"""
+# Data structures.
+/src/structures_detroix23/__init__.py
+"""
+
+from structures_detroix23.modules import (
+	base,
+	cell,
+	dynamic_list,
+	graphs,
+	nodes,
+	result,
+	types,
+)

structures_detroix23-0.0.3/src/structures_detroix23/__main__.py

@@ -0,0 +1,130 @@
+"""
+# Data structures.
+/src/structures_detroix23/__main__.py
+Main file.
+"""
+
+import sys
+
+from structures_detroix23.modules import (
+	base,
+	cell,
+	dynamic_list,
+	nodes,
+)
+
+def test_chain1() -> None:
+	"""
+	Main chained list test entry point.
+	"""
+	print("\n(?) main.test_chain1() Start.")
+
+	base.verbose_assert_eq(cell.Cell(1).to_list(), [1])
+
+	assert (cell.Cell(1, cell.Cell(2, cell.Cell(3)))).to_list() == [1, 2, 3]
+	
+	c3: cell.Cell[int] = cell.new_from([1, 2, 3, 4])
+	assert c3.to_list() == [1, 2, 3, 4]
+
+	base.verbose_assert_eq(c3.go(0).value, 1)
+	base.verbose_assert_eq(c3.go(1).value, 2)
+	base.verbose_assert_eq(c3.go(2).value, 3)
+	base.verbose_assert_eq(c3.go(3).value, 4)
+
+	print("(?) main.test_chain1() Passed.\n")
+	return
+
+def test_list1() -> None:
+	print("\n(?) main.test_chain1() Start.")
+
+	c1: cell.Cell[int] = cell.new_from([3, 4, 5])
+
+	l1: dynamic_list.DynamicList[int] = dynamic_list.DynamicList()
+	l1.append(1)
+	l1.append(2)
+	l1.push(c1)
+
+	print(f"l1={l1}, len={len(l1)}, l={l1.to_list()}")
+
+	l2: dynamic_list.DynamicList[int] = dynamic_list.DynamicList()
+	print(f"l2={l2}, len={len(l2)}, l={l2.to_list()}")
+
+	l3: dynamic_list.DynamicList[int] = dynamic_list.DynamicList()
+	l3.append(1)
+	print(f"l3={l3}, len={len(l3)}, l={l3.to_list()}")
+
+	print("(?) main.test_chain1() Passed.\n")
+	return
+
+def test_graph1() -> None:
+	"""
+	Test nodes and graphs.
+	"""
+	n1 = nodes.Node("A")
+	n2 = nodes.Node("B")
+	n3 = nodes.Node("C")
+	n4 = nodes.Node("D")
+
+	print(n1)
+	print(n2)
+	print(n3)
+	print(n4)
+
+	n1.batch_next((
+		(n1, 1),
+		(n2, 2),
+		(n3, 2),
+		(n4, 5)
+	))
+
+	n1.batch_previous((
+		(n3, 4),
+		(n4, 1)
+	))
+
+	n4.batch_next((
+		(n2, 2),
+		(n3, 1),
+	))
+
+	print(n1, n1.display('  '))
+
+
+
+
+def help() -> str:
+	return """## Help.
+
+### Arguments.
+`--test` | `-t`: Launch testing;
+
+"""
+
+def test() -> None:
+	print("## Tests.")
+
+	# test_chain1()
+	# test_list1()
+
+	test_graph1()
+
+	return	
+
+def main() -> None:
+	print("# Data structures.")
+
+	arguments: list[str] = sys.argv
+
+	if len(arguments) == 1:
+		print("\nUser selected no arguments.\n")
+		
+		print(help())
+		return
+
+	for argument in arguments:
+		if argument in {"--test", "-t"}:
+			test()
+
+	return
+
+main()

structures_detroix23-0.0.3/src/structures_detroix23/modules/__init__.py

@@ -0,0 +1,4 @@
+"""
+# Data structures.
+/src/structures_detroix23/modules/__init__.py
+"""

structures_detroix23-0.0.3/src/structures_detroix23/modules/base.py

@@ -0,0 +1,18 @@
+"""
+# Data structures.
+/src/structures_detroix23/modules/base.py.
+Base.
+"""
+
+from typing import Any
+
+def verbose_assert_eq(a: Any, b: Any) -> bool:
+	"""
+	Compare 2 values.
+	- raise `AssertionError` if not equal, and prints the values.
+	- returns `True` if passed. 
+	"""
+	if a != b:
+		raise AssertionError(f"(X) verbose_assert_eq(a={a}, b={b}) `a` != `b`.")
+	else:
+		return True

structures_detroix23-0.0.3/src/structures_detroix23/modules/cell.py

@@ -0,0 +1,99 @@
+"""
+# Data structures.
+/src/structures_detroix23/modules/chain.py
+"""
+
+from typing import Optional, TypeVar, Generic
+
+_T_CELL = TypeVar("_T_CELL")
+
+class Cell(Generic[_T_CELL]):
+	"""
+	Define a cell from a chained list.
+	"""
+	_value: _T_CELL
+	_following: Optional['Cell[_T_CELL]']
+
+	def __init__(self, value: _T_CELL, following: Optional['Cell[_T_CELL]'] = None) -> None:
+		self._value = value
+		self._following = following
+
+	def __str__(self) -> str:
+		display: list[str] = []
+		current: Optional[Cell[_T_CELL]] = self.clone()
+		while current is not None:
+			display.append(str(current.value))
+			current = current.following
+
+		return f"<{', '.join(display)}>"
+
+	def __repr__(self) -> str:
+		return f"chain.Cell(value={self.value}, following={repr(self.following)})"
+
+	def clone(self) -> 'Cell[_T_CELL]':
+		return Cell(
+			value=self.value,
+			following=self.following,
+		)
+
+	@property
+	def value(self) -> _T_CELL:
+		"""
+		Get the read-only `value` of the cell.
+		"""
+		return self._value
+
+	@property
+	def following(self) -> Optional['Cell[_T_CELL]']:
+		"""
+		Get the read-only `following` next cell. Return `None` if has no following.
+		"""
+		return self._following
+
+	def set_following(self, new: 'Cell[_T_CELL]') -> None:
+		"""
+		Set the `following` to a `new` cell.
+		"""
+		print(f"(?) set_following={new}")
+		self._following = new
+
+
+	def to_list(self) -> list[_T_CELL]:
+		"""
+		Returns a `list[_T_CELL]` of the values.
+		"""
+		current: Cell[_T_CELL] = self.clone()
+		l: list[_T_CELL] = [current.value]
+
+		while current.following is not None:
+			current = current.following
+			l.append(current.value)
+		
+		return l
+	
+	def go(self, steps: int) -> 'Cell[_T_CELL]':
+		"""
+		Move up `steps` times, and return the `Cell`.
+		Throws an `IndexError` if the index is out of range.
+		"""
+		current: Cell[_T_CELL] = self.clone()
+		
+		while steps > 0:
+			if current.following is None:
+				raise IndexError(f"(X) - modules.chain.Cell.go - Index out of range. steps={steps}, cell={repr(current)}")
+			current = current.following
+
+			steps -= 1
+
+		return current
+
+def new_from(values: list[_T_CELL]) -> 'Cell[_T_CELL]':
+	"""
+	Generate a chained list from a given `values` list.
+	"""
+	values.reverse()
+	current: Cell[_T_CELL] = Cell(values[0])
+	for value in values[1:]:
+		current = Cell(value, current)
+
+	return current

structures_detroix23-0.0.3/src/structures_detroix23/modules/dynamic_list.py

@@ -0,0 +1,105 @@
+"""
+# Data structures.
+/src/structures_detroix23/modules/dynamic_list.py
+"""
+
+from typing import Optional, TypeVar, Generic
+
+from structures_detroix23.modules import (
+	cell,
+)
+
+_T_LIST = TypeVar("_T_LIST")
+
+class DynamicList(Generic[_T_LIST]):
+	"""
+	# `DynamicList`.
+	"""
+	data: Optional[cell.Cell[_T_LIST]]
+
+	def __init__(self, data: Optional[cell.Cell[_T_LIST]] = None) -> None:
+		self.data = data
+
+	def __len__(self) -> int:
+		counter: int = 0
+
+		if self.data is not None:
+			current: cell.Cell[_T_LIST] = self.data
+			counter += 1
+
+			while current.following is not None:
+				current = current.following
+				counter += 1
+
+		return counter
+
+	def __repr__(self) -> str:
+		if self.is_empty():
+			return f"DynamicList(None)"
+		else:
+			return f"DynamicList({repr(self.data)})"
+
+	def __str__(self) -> str:
+		if self.is_empty():
+			return f"List<>"
+		else:
+			return f"List{self.data}"
+
+	def is_empty(self) -> bool:
+		"""
+		Return `True` if the list is empty.
+		"""
+		return self.data is None
+
+	def to_list(self) -> list[_T_LIST]:
+		if self.data is None:
+			return []
+
+		current: cell.Cell[_T_LIST] = self.data
+		l: list[_T_LIST] = [current.value]
+
+		while current.following is not None:
+			current = current.following
+			l.append(current.value)
+
+		return l
+	
+	def get_last(self) -> cell.Cell[_T_LIST]:
+		"""
+		Get a reference to the last `Cell` of the list.
+
+		Raises a `ValueError` if the list is empty.
+		"""
+		if self.data is None:
+			raise ValueError(f"(X) modules.dynamic_list.DynamicList.get_last() list ({self}) is empty.")
+		
+		current: cell.Cell[_T_LIST] = self.data
+
+		while current.following is not None:
+			current = current.following
+		
+		return current
+
+
+	def push(self, new: cell.Cell[_T_LIST]) -> None:
+		"""
+		Add a `Cell` to the `following` of the last current `Cell`. 
+		"""
+		if self.data is None:
+			self.data = new
+
+		else:
+			last = self.get_last()
+			print(f"(?) last={last}", end=" ")
+			last.set_following(new)
+			print(f"(?) last={last}, self.get_last={self.get_last()}")
+
+
+	def append(self, value: _T_LIST) -> None:
+		"""
+		Add an item `value` to the end of the list.
+
+		Creates a new `Cell` englobing the `value. 
+		"""
+		self.push(cell.Cell(value, None))
+	

structures_detroix23-0.0.3/src/structures_detroix23/modules/graphs.py

@@ -0,0 +1,56 @@
+"""
+# Data structures.
+/src/structures_detroix23/modules/graphs.py
+"""
+
+from typing import Optional
+
+from structures_detroix23.modules import (
+	nodes,
+)
+
+class Graph:
+	"""
+	Describe abstractly the base of any `Graph` representation.
+	"""
+	register: list[nodes.Node]
+
+	def __init__(
+		self, 
+		register: Optional[list[nodes.Node]]
+	) -> None:
+		self.register = register if register is not None else []
+
+
+class Explorer:
+	"""
+	Allows the exploring of a graph without infinite recursion.
+	""" 
+	graph: Graph
+	current: nodes.Node
+	seen: set[nodes.Node]
+
+	def __init__(self, graph: Graph, current: nodes.Node) -> None:
+		self.graph = graph
+		self.current = current
+		self.seen = set()
+		
+
+	def move(self, destination: nodes.Node) -> bool:
+		"""
+		Move to a `Node`. Return `True` if succeed, `False` if:
+		- is not reachable from `current`,
+		- has already been `seen`.
+		"""
+		if (
+			destination in self.current.get_next().keys()
+			and destination not in self.seen
+		):
+			self.current = destination
+			return True
+		
+		return False
+	
+
+
+	

structures_detroix23-0.0.3/src/structures_detroix23/modules/nodes.py

@@ -0,0 +1,173 @@
+"""
+# Data structures.
+/src/structures_detroix23/modules/nodes.py.
+"""
+
+from typing import Optional, Self, Iterable
+
+from structures_detroix23.modules.types import Weight 
+
+class Node:
+	"""
+	# `Node`.
+	Define a named cell, holding no value except:  
+	- `_name`: `str`, a globally unique name.
+	- `_previous`: `dict['Node', Weight]`, containing as many references to other nodes.
+	- `_next`: `dict['Node', Weight]`, containing as many references to other nodes.
+
+	Class variables:
+	- `last_id`: `int`, store the last created id, to ensure uniqueness.
+	"""
+	_last_id: int = 0
+
+	_id: int
+	_name: str
+	_previous: dict['Node', Weight]
+	_next: dict['Node', Weight]
+
+	def __new__(
+		cls,
+		name: str,
+		previous: Optional[dict['Node', Weight]] = None,
+		next: Optional[dict['Node', Weight]] = None,
+	) -> Self:
+		new: Self = super(Node, cls).__new__(cls)
+		
+		new._id = Node._last_id
+		Node._last_id += 1
+
+		return new
+
+	def __init__(
+		self, 
+		name: str,
+		previous: Optional[dict['Node', Weight]] = None,
+		next: Optional[dict['Node', Weight]] = None,
+	) -> None:
+		"""
+		Instantiate a new `Node`.
+		- `name` must be unique globally.
+		"""
+		self._name = name
+		self._previous = previous if previous is not None else {}
+		self._next = next if next is not None else {}
+
+	def __hash__(self) -> int:
+		return self.get_id()
+
+	def __repr__(self) -> str:
+		return f"Node(name={self._name}, id={self._id}, previous={self._previous}, next={self._next})"
+
+	def __str__(self) -> str:
+		return f"{self._name}"
+
+	def get_id(self) -> int:
+		"""
+		Returns the unique, read-only `_id` of the `Node`.
+		"""
+		return self._id
+
+	def get_name(self) -> str:
+		"""
+		Returns the read-only `_name` of the `Node`.
+		"""
+		return self._name
+
+	def get_previous(self) -> dict['Node', Weight]:
+		"""
+		Returns the read-only `_previous` of the `Node`.
+		"""
+		return self._previous
+	
+	def get_next(self) -> dict['Node', Weight]:
+		"""
+		Returns the read-only `_next` of the `Node`.
+		"""
+		return self._next
+	
+	def set_previous(self, node: 'Node', weight: Weight) -> None:
+		"""
+		Create or update in `previous` the `node` with `weight`.
+		"""
+		self._previous[node] = weight
+
+	def set_next(self, node: 'Node', weight: Weight) -> None:
+		"""
+		Create or update in `next` the `node` with `weight`.
+		"""
+		self._next[node] = weight
+
+	def batch_previous(self, nodes: Iterable[tuple['Node', Weight]]) -> None:
+		"""
+		Update multiple `nodes` in `previous`, from an `Iterable` of `(Node, Weight)`.
+		"""
+		for node, weight in nodes:
+			self.set_previous(node, weight)
+
+	def batch_next(self, nodes: Iterable[tuple['Node', Weight]]) -> None:
+		"""
+		Update multiple `nodes` in `next`, from an `Iterable` of `(Node, Weight)`.
+		"""
+		for node, weight in nodes:
+			self.set_next(node, weight)
+
+
+	def remove_previous(self, node: 'Node') -> Optional[Weight]:
+		"""
+		Remove the given `node` from `previous`.
+		
+		Return the weight, or `None` if `node` didn't existed. 
+		"""
+		self._previous.pop(node, None)
+	
+	def remove_next(self, node: 'Node') -> Optional[Weight]:
+		"""
+		Remove the given `node` from `next`.
+		
+		Return the weight, or `None` if `node` didn't existed. 
+		"""
+		self._next.pop(node, None)
+
+	def display(
+		self, 
+		tab: str, 
+		level: int = 0,
+		seen: Optional[set['Node']] = None,
+	) -> str:
+		"""
+		Multiple line readable representation of the `Node`.
+		"""
+		seen_current: set[Node] = seen if seen is not None else set[Node]()
+
+		return "\n".join([
+			"{",
+			f"{tab * (level + 1)}previous: {pretty(self.get_previous(), seen_current, tab, level + 1)},",
+			f"{tab * (level + 1)}next: {pretty(self.get_next(), seen_current, tab, level + 1)},",
+			f"{tab * level}" + "}"
+		])
+	
+def pretty(
+	iterable: dict['Node', Weight],
+	seen: set['Node'],
+	tab: str = "\t",
+	level: int = 0,
+) -> str:
+	"""
+	Return a pretty formatted line broken string of a `dict`.
+	"""
+	
+	lines: list[str] = ["{"]
+
+	if len(iterable) == 0:
+		return "{}"
+
+	for node, weight in iterable.items():
+		if node in seen:
+			lines.append(f"{tab * (level + 1)}{node}: {weight}")
+		else:
+			seen.add(node)
+			lines.append(f"{tab * (level + 1)}{node}: {weight}, {node.display(tab, level + 1, seen)}")
+
+	lines.append(tab * level + "}")
+
+	return "\n".join(lines)

structures_detroix23-0.0.3/src/structures_detroix23/modules/result.py

@@ -0,0 +1,60 @@
+"""
+# Data structures.
+/src/structures_detroix23/modules/nodes.py.
+"""
+
+from typing import Optional, TypeVar, Generic
+
+_T_RESULT_ERROR = TypeVar("_T_RESULT_ERROR")
+_T_RESULT_OK = TypeVar("_T_RESULT_OK")
+
+
+class UnwrapException(Exception):
+	"""
+	# `UnwrapException`.
+	Raised when trying to unwrap a `Result` containing an error.
+	"""
+	message: str
+
+	def __init__(self, message: str) -> None:
+		super().__init__(message)
+		self.message = message
+
+	def __str__(self) -> str:
+		return super().__str__()
+
+
+class Result(Generic[_T_RESULT_OK, _T_RESULT_ERROR]):
+	"""
+	# `Result`.
+	Rust like `Result`, containing or an error, or a success value. 
+
+	Define 2 generics:
+	1. `_T_RESULT_OK`,
+	2. `_T_RESULT_ERROR`.
+	"""
+	ok: Optional[_T_RESULT_OK]
+	error: Optional[_T_RESULT_ERROR]
+
+	def __init__(
+		self, 
+		ok: Optional[_T_RESULT_OK], 
+		error: Optional[_T_RESULT_ERROR]
+	) -> None:
+		self.ok = ok
+		self.error = error
+	
+	def unwrap(self) -> _T_RESULT_OK:
+		"""
+		Return the `ok` value. If there is an `error, raise an `UnwrapException`. 
+		"""
+		if self.error is not None or self.ok is None:
+			raise UnwrapException(str(self.error))
+		
+		return self.ok
+
+	def is_ok(self) -> bool:
+		"""
+		Return `True` if no error.
+		"""
+		return self.error is None and self.ok is not None

structures_detroix23-0.0.3/src/structures_detroix23/modules/types.py

@@ -0,0 +1,8 @@
+"""
+# Data structures.
+/src/structures_detroix23/modules/types.py
+"""
+
+from typing import Union
+
+Weight = Union[int, float]

structures_detroix23-0.0.3/src/structures_detroix23.egg-info/PKG-INFO

@@ -0,0 +1,24 @@
+Metadata-Version: 2.4
+Name: structures_detroix23
+Version: 0.0.3
+Summary: Python structures.
+Author-email: Detroix23 <detroix23@gmail.com>
+License-Expression: CC-BY-4.0
+Project-URL: Repository, https://github.com/Detroix23/py_structures
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Classifier: Natural Language :: English
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE.md
+Dynamic: license-file
+
+# Data structures.
+
+Classes:
+- Chained lists (algorithmically);
+- Stack;
+- Queue;
+- Doubly-chained lists;
+- Tree;
+- Graphs;

structures_detroix23-0.0.3/src/structures_detroix23.egg-info/SOURCES.txt

@@ -0,0 +1,17 @@
+LICENSE.md
+README.md
+pyproject.toml
+src/structures_detroix23/__init__.py
+src/structures_detroix23/__main__.py
+src/structures_detroix23.egg-info/PKG-INFO
+src/structures_detroix23.egg-info/SOURCES.txt
+src/structures_detroix23.egg-info/dependency_links.txt
+src/structures_detroix23.egg-info/top_level.txt
+src/structures_detroix23/modules/__init__.py
+src/structures_detroix23/modules/base.py
+src/structures_detroix23/modules/cell.py
+src/structures_detroix23/modules/dynamic_list.py
+src/structures_detroix23/modules/graphs.py
+src/structures_detroix23/modules/nodes.py
+src/structures_detroix23/modules/result.py
+src/structures_detroix23/modules/types.py

structures_detroix23-0.0.3/src/structures_detroix23.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

structures_detroix23-0.0.3/src/structures_detroix23.egg-info/top_level.txt

@@ -0,0 +1 @@
+structures_detroix23