graphitedb 0.1.3__py3-none-any.whl → 0.2__py3-none-any.whl

graphite/migration.py

@@ -0,0 +1,104 @@
+"""
+Helper module to update Graphite databases and handle other migrations
+"""
+import warnings
+import pickle
+import os
+import glob
+from .engine import GraphiteEngine
+from .utils import SecurityWarning
+
+class Migration:
+	"""Utility for migrating from older versions"""
+
+	@staticmethod
+	def convert_pickle_to_json(
+		pickle_file: str, json_file: str, delete_original: bool = False
+	) -> bool:
+		"""
+		Convert a pickle file to JSON format
+
+		Args:
+			pickle_file: Path to existing pickle file
+			json_file: Path for new JSON file
+			delete_original: Whether to delete pickle file after conversion
+
+		Returns:
+			True if successful, False otherwise
+		"""
+		try:
+			warnings.warn(
+				"'convert_pickle_to_json' will be deprecated because of security reasons. "
+				"Please convert your pickle files to JSON and don't use old files anymore.",
+				PendingDeprecationWarning
+			)
+
+			# Load from pickle (with safety warnings)
+			warnings.warn(
+				f"Loading from pickle file: {pickle_file}. "
+				"Pickle files can contain malicious code. "
+				"Only load files from trusted sources.",
+				SecurityWarning
+			)
+
+			with open(pickle_file, 'rb') as f:
+				data = pickle.load(f)
+
+			# Create a new engine with the loaded data
+			converter_engine = GraphiteEngine()
+
+			# Restore data structures
+			converter_engine.node_types = data['node_types']
+			converter_engine.relation_types = data['relation_types']
+			converter_engine.nodes = data['nodes']
+			converter_engine.relations = data['relations']
+			converter_engine.node_by_type = data['node_by_type']
+			converter_engine.relations_by_type = data['relations_by_type']
+			converter_engine.relations_by_from = data['relations_by_from']
+			converter_engine.relations_by_to = data['relations_by_to']
+
+			# Save to JSON
+			converter_engine.save(json_file)
+
+			if delete_original:
+				os.unlink(pickle_file)
+				print(f"Converted {pickle_file} to {json_file} and deleted original")
+			else:
+				print(f"Converted {pickle_file} to {json_file}")
+
+			return True
+
+		except Exception as e: # pylint: disable=broad-exception-caught
+			print(f"Conversion failed: {e}")
+			return False
+
+	@staticmethod
+	def detect_pickle_and_convert_to_json(
+		directory: str, pattern: str = "*.db", delete_originals: bool = False
+	):
+		"""
+		Find and convert all pickle files in a directory
+
+		Args:
+			directory: Directory to scan
+			pattern: File pattern to match (default: *.db)
+			delete_originals: Whether to delete pickle files after conversion
+		"""
+		for pickle_file in glob.glob(os.path.join(directory, pattern)):
+			if pickle_file.endswith('.json'):
+				continue
+
+			json_file = pickle_file.rsplit('.', 1)[0] + '.json'
+
+			try:
+				# Quick check if it's a pickle file
+				with open(pickle_file, 'rb') as f:
+					# Try to read pickle header
+					header = f.read(4)
+					if header == b'\x80\x04' or header.startswith(b'\x80'):  # Pickle protocol 4
+						Migration.convert_pickle_to_json(
+							pickle_file, json_file, delete_originals
+						)
+			except Exception as e: # pylint: disable=broad-exception-caught
+				# Not a pickle file or can't read
+				print(f"File '{pickle_file}' skipped: {e}")

graphite/parser.py

@@ -0,0 +1,228 @@
+"""
+Parser for Graphite DSL
+"""
+import re
+from datetime import date, datetime
+from typing import Any, List, Optional, Tuple, Union
+
+from .exceptions import DateParseError, FieldError, NotFoundError, SchemaError
+from .types import DataType, Field
+
+class GraphiteParser:
+	"""Parser for Graphite DSL"""
+
+	def parse_field_value(self, value: Any, field: Field) -> Any:
+		"""
+		Parse a raw value for a field (node or relation) and return it.
+
+		**Note:** Value will be validated with field information, use ``parse_value()``
+		to ignore validation.
+		"""
+		value = self.parse_value(value)
+		return self.validate_field_value(value, field)
+
+	@staticmethod
+	# pylint: disable=broad-exception-caught, too-many-branches
+	def validate_field_value(value: Any, field: Field) -> Any:
+		"""
+		Converts given value to field's data type. Raises ``FieldError`` at fail.
+		"""
+		if value is None:
+			return None
+		exc = None
+		if field.dtype == DataType.STRING and not isinstance(value, str):
+			try:
+				value = str(exc)
+			except Exception as e:
+				exc = e
+		elif field.dtype == DataType.INT and not isinstance(value, int):
+			try:
+				value = int(value)
+			except Exception as e:
+				exc = e
+		elif field.dtype == DataType.DATE and not isinstance(value, (datetime, date)):
+			try:
+				value = datetime.strptime(value, "%Y-%m-%d").date()
+			except Exception as e:
+				exc = e
+		elif field.dtype == DataType.FLOAT and not isinstance(value, float):
+			try:
+				value = float(value)
+			except Exception as e:
+				exc = e
+		elif field.dtype == DataType.BOOL and not isinstance(value, bool):
+			if isinstance(value, str):
+				value = value.lower() == "true"
+			else:
+				try:
+					value = bool(value)
+				except Exception as e:
+					exc = e
+		elif field.dtype not in DataType:
+			raise NotFoundError(
+				"Data type",
+				str(field.dtype)
+			)
+		if exc is not None:
+			raise FieldError(
+				field,
+				value
+			) from exc
+		return value
+
+	@staticmethod
+	# pylint: disable=too-many-return-statements
+	def parse_value(value: Any) -> Any:
+		"""Parses a raw value (usually ``str``) into correct type."""
+		if not isinstance(value, str):
+			return value
+		value = value.strip()
+		if value.startswith('"') and value.endswith('"'):
+			return value[1:-1]
+		if value.replace('-', '').isdigit() and value.count("-") == 2:  # Date-like
+			try:
+				return datetime.strptime(value, '%Y-%m-%d').date()
+			except ValueError as e:
+				raise DateParseError(value) from e
+		if value.isdigit() or (value.startswith('-') and value[1:].isdigit()):
+			return int(value)
+		if value.replace('.', '').isdigit() and value.count('.') == 1:
+			return float(value)
+		if value.lower() in ('true', 'false'):
+			return value.lower() == 'true'
+		return value
+
+	@staticmethod
+	def parse_node_definition(line: str) -> Tuple[str, List[Field], str]:
+		"""Parse node type definition: 'node Person\nname: string\nage: int'"""
+		lines = line.strip().split('\n')
+		first_line = lines[0].strip()
+
+		# Parse inheritance
+		if ' from ' in first_line:
+			parts = first_line.split(' from ')
+			node_name = parts[0].replace('node', '').strip()
+			parent = parts[1].strip()
+			fields_start = 1
+		else:
+			node_name = first_line.replace('node', '').strip()
+			parent = None
+			fields_start = 1
+
+		fields = []
+		for field_line in lines[fields_start:]:
+			field_line = field_line.strip()
+			if not field_line:
+				continue
+			name_type = field_line.split(':')
+			if len(name_type) == 2:
+				name = name_type[0].strip()
+				dtype_str = name_type[1].strip()
+				dtype = DataType(dtype_str)
+				fields.append(Field(name, dtype))
+
+		return node_name, fields, parent
+
+	# pylint: disable=too-many-locals
+	@staticmethod
+	def parse_relation_definition(line: str) -> Tuple[str, str, str, List[Field], Optional[str], bool]:
+		"""Parse relation definition"""
+		lines = line.strip().split('\n')
+		first_line = lines[0].strip()
+
+		# Check for 'both' keyword
+		is_bidirectional = ' both' in first_line
+		if is_bidirectional:
+			first_line = first_line.replace(' both', '')
+
+		# Parse reverse
+		reverse_name = None
+		if ' reverse ' in first_line:
+			parts = first_line.split(' reverse ')
+			relation_name = parts[0].replace('relation', '').strip()
+			reverse_name = parts[1].strip()
+		else:
+			relation_name = first_line.replace('relation', '').strip()
+
+		# Parse participants
+		participants_line = lines[1].strip()
+		if '->' in participants_line:
+			from_to = participants_line.split('->')
+			from_type = from_to[0].strip()
+			to_type = from_to[1].strip()
+		elif '-' in participants_line:
+			parts = participants_line.split('-')
+			from_type = parts[0].strip()
+			to_type = parts[2].strip() if len(parts) > 2 else parts[1].strip()
+		else:
+			raise SchemaError(f"Invalid relation type format: {participants_line}")
+
+		# Parse fields
+		fields = []
+		for field_line in lines[2:]:
+			field_line = field_line.strip()
+			if not field_line:
+				continue
+			name_type = field_line.split(':')
+			if len(name_type) == 2:
+				name = name_type[0].strip()
+				dtype_str = name_type[1].strip()
+				dtype = DataType(dtype_str)
+				fields.append(Field(name, dtype))
+
+		return relation_name, from_type, to_type, fields, reverse_name, is_bidirectional
+
+	@staticmethod
+	def parse_node_instance(line: str) -> Tuple[str, str, List[Any]]:
+		"""Parse node instance: 'User, user_1, "Joe Doe", 32, "joe4030"'"""
+		# Handle quoted strings
+		parts = []
+		current = ''
+		in_quotes = False
+		for char in line:
+			if char == '"':
+				in_quotes = not in_quotes
+				current += char
+			elif char == ',' and not in_quotes:
+				parts.append(current.strip())
+				current = ''
+			else:
+				current += char
+		if current:
+			parts.append(current.strip())
+
+		node_type = parts[0].strip()
+		node_id = parts[1].strip()
+		values = list(map(GraphiteParser.parse_value, parts[2:]))
+
+		return node_type, node_id, values
+
+	@staticmethod
+	def parse_relation_instance(
+		line: str
+	) -> tuple[Union[str, Any], Union[str, Any], Any, list[Any], str]:
+		"""Parse relation instance: 'user_1 -[OWNER, 2000-10-04]-> notebook'"""
+		# Extract relation type and attributes
+		pattern = r'(\w+)\s*(-\[([^\]]+)\]\s*[->-]\s*|\s*[->-]\s*\[([^\]]+)\]\s*->\s*)(\w+)'
+		match = re.search(pattern, line)
+		if not match:
+			raise SchemaError(f"Invalid relation format: {line}")
+
+		from_node = match.group(1)
+		to_node = match.group(5)
+
+		# Get relation type and attributes
+		rel_part = match.group(3) or match.group(4)
+		rel_parts = [p.strip() for p in rel_part.split(',')]
+		rel_type = rel_parts[0]
+		attributes = list(map(GraphiteParser.parse_value, rel_parts[1:]) if len(rel_parts) > 1 else [])
+
+		# Parse direction
+		if '->' in line:
+			direction = 'forward'
+		elif '-[' in line and ']-' in line:
+			direction = 'bidirectional'
+		else:
+			direction = 'forward'
+
+		return from_node, to_node, rel_type, attributes, direction

graphite/query.py

@@ -0,0 +1,199 @@
+"""
+Query engine and object for Graphite
+"""
+from datetime import date, datetime
+from typing import TYPE_CHECKING, List, Callable, Optional, Union
+
+from .instances import Node, Relation
+from .types import RelationType
+from .exceptions import ConditionError, DateParseError, NotFoundError
+
+if TYPE_CHECKING:
+	from .engine import GraphiteEngine
+
+class QueryResult:
+	"""Represents a query result that can be chained"""
+
+	def __init__(
+		self, graph_engine: 'GraphiteEngine', nodes: List[Node], edges: List[Relation] = None
+	):
+		self.engine = graph_engine
+		self.nodes = nodes
+		self.edges = edges or []
+		self.current_relation: Optional[RelationType] = None
+		self.direction: str = 'outgoing'
+
+	def where(self, condition: Union[str, Callable]):
+		"""Filter nodes based on condition"""
+		filtered_nodes = []
+
+		if callable(condition):
+			# Lambda function
+			for processing_node in self.nodes:
+				try:
+					if condition(processing_node):
+						filtered_nodes.append(processing_node)
+				except Exception as e:
+					raise ConditionError(str(condition)) from e
+		else:
+			# String condition like "age > 18"
+			for processing_node in self.nodes:
+				if self._evaluate_condition(processing_node, condition):
+					filtered_nodes.append(processing_node)
+
+		return QueryResult(self.engine, filtered_nodes, self.edges)
+
+	# pylint: disable=too-many-branches
+	@staticmethod
+	def _evaluate_condition(target_node: Node, condition: str) -> bool:
+		"""Evaluate a condition string on a node"""
+		# Simple condition parser
+		ops = ['>=', '<=', '!=', '==', '>', '<', '=']
+
+		for op in ops:
+			if op in condition:
+				left, right = condition.split(op)
+				left = left.strip()
+				right = right.strip()
+
+				# Get value from node
+				node_value = target_node.get(left)
+				if node_value is None:
+					return False
+
+				# Parse right side
+				if right[0] in ('"', "'") and right[-1] in ('"', "'"):
+					right_value = right[1:-1]
+				elif right.isdigit():
+					right_value = int(right)
+				elif right.replace('.', '').isdigit() and right.count('.') == 1:
+					right_value = float(right)
+				else:
+					right_value = right
+
+				if right_value == "true":
+					right_value = True
+				elif right_value == "false":
+					right_value = False
+
+				if isinstance(node_value, date):
+					try:
+						right_value = datetime.strptime(right_value, "%Y-%m-%d").date()
+					except Exception as e:
+						raise DateParseError(right_value) from e
+
+				# Apply operation
+				result = None
+				try:
+					if op in ('=', '=='):
+						result = node_value == right_value
+					if op == '!=':
+						result = node_value != right_value
+					if op == '>':
+						result = node_value > right_value
+					if op == '<':
+						result = node_value < right_value
+					if op == '>=':
+						result = node_value >= right_value
+					if op == '<=':
+						result = node_value <= right_value
+				except TypeError as e:
+					raise e
+				if result is None:
+					raise ConditionError(condition)
+				return result
+
+		raise ConditionError(condition)
+
+	def traverse(self, relation_type: str, direction: str = 'outgoing'):
+		"""Traverse relations from current nodes"""
+		result_nodes = []
+		result_edges = []
+
+		for processing_node in self.nodes:
+			if direction == 'outgoing':
+				edges = self.engine.get_relations_from(processing_node.id, relation_type)
+			elif direction == 'incoming':
+				edges = self.engine.get_relations_to(processing_node.id, relation_type)
+			else:  # both
+				edges = (self.engine.get_relations_from(processing_node.id, relation_type) +
+						 self.engine.get_relations_to(processing_node.id, relation_type))
+
+			for edge in edges:
+				result_edges.append(edge)
+				target_id = edge.to_node if direction == 'outgoing' else edge.from_node
+				target_node = self.engine.get_node(target_id)
+				if target_node:
+					result_nodes.append(target_node)
+
+		# Remove duplicates
+		result_nodes = list(dict((n.id, n) for n in result_nodes).values())
+		return QueryResult(self.engine, result_nodes, result_edges)
+
+	def outgoing(self, relation_type: str):
+		"""Traverse outgoing relations"""
+		return self.traverse(relation_type, 'outgoing')
+
+	def incoming(self, relation_type: str):
+		"""Traverse incoming relations"""
+		return self.traverse(relation_type, 'incoming')
+
+	def both(self, relation_type: str):
+		"""Traverse both directions"""
+		return self.traverse(relation_type, 'both')
+
+	def limit(self, n: int):
+		"""Limit number of results"""
+		return QueryResult(self.engine, self.nodes[:n], self.edges[:n])
+
+	def distinct(self):
+		"""Get distinct nodes"""
+		seen = set()
+		distinct_nodes = []
+		for processing_node in self.nodes:
+			if processing_node.id not in seen:
+				seen.add(processing_node.id)
+				distinct_nodes.append(processing_node)
+		return QueryResult(self.engine, distinct_nodes, self.edges)
+
+	def order_by(self, by_field: str, descending: bool = False):
+		"""Order nodes by field"""
+
+		def get_key(from_node):
+			val = from_node.get(by_field)
+			return val is None, val
+
+		sorted_nodes = sorted(self.nodes, key=get_key, reverse=descending)
+		return QueryResult(self.engine, sorted_nodes, self.edges)
+
+	def count(self) -> int:
+		"""Count nodes"""
+		return len(self.nodes)
+
+	def get(self) -> List[Node]:
+		"""Get all nodes"""
+		return self.nodes
+
+	def first(self) -> Optional[Node]:
+		"""Get first node"""
+		return self.nodes[0] if self.nodes else None
+
+	def ids(self) -> List[str]:
+		"""Get node IDs"""
+		return [n.id for n in self.nodes]
+
+class QueryBuilder:  # pylint: disable=too-few-public-methods
+	"""Builder for creating queries"""
+
+	def __init__(self, graphite_engine: 'GraphiteEngine'):
+		self.engine = graphite_engine
+
+	def __getattr__(self, name: str) -> QueryResult:
+		"""Allow starting query from node type: engine.User"""
+		if name in self.engine.node_types:
+			nodes = self.engine.get_nodes_of_type(name)
+			return QueryResult(self.engine, nodes)
+		raise NotFoundError(
+			"Node type",
+			name
+		)

graphite/serialization.py

@@ -0,0 +1,174 @@
+"""
+Serialization utils for Graphite databases
+"""
+import json
+from collections import defaultdict
+from dataclasses import asdict, is_dataclass
+from datetime import date, datetime
+from enum import Enum
+from typing import Any, Callable, Union
+
+from .instances import Node, Relation
+from .types import DataType, Field, NodeType, RelationType
+
+GRAPHITE_TYPE_FIELD = "__graphite_type__"
+DEFAULT_FACTORY_FIELD = "__default_factory"
+
+def _serialize_instance(instance: Union[Node, Relation]) -> dict[str, Any]:
+	return {
+		GRAPHITE_TYPE_FIELD: type(instance).__name__,
+		"type_name"        : instance.type_name,
+		"id"               : instance.id if hasattr(instance, "id") else None,
+		"values"           : instance.values,
+		"from_node"        : instance.from_node if hasattr(instance, "from_node") else None,
+		"to_node"          : instance.to_node if hasattr(instance, "to_node") else None,
+		"type_ref"         : instance.type_ref.name if instance.type_ref else None
+	}
+
+class GraphiteJSONEncoder(json.JSONEncoder):
+	"""Custom JSON encoder for Graphite data structures"""
+
+	def default(self, o: Any) -> Any:  # pylint: disable=too-many-return-statements
+		# Handle date/datetime objects
+		if isinstance(o, (date, datetime)):
+			return {
+				GRAPHITE_TYPE_FIELD: "datetime",
+				"value"            : o.isoformat(),
+				"is_date"          : isinstance(o, date)
+			}
+
+		# Handle DataType enum specifically (must come before Enum)
+		if isinstance(o, DataType):
+			return {
+				GRAPHITE_TYPE_FIELD: "datatype",
+				"value"            : o.value
+			}
+
+		# Handle Enum objects
+		if isinstance(o, Enum):
+			return {
+				GRAPHITE_TYPE_FIELD: "enum",
+				"enum_class"       : type(o).__name__,
+				"value"            : o.value
+			}
+
+		# Handle defaultdict
+		if isinstance(o, defaultdict):
+			result = dict(o)
+			result[GRAPHITE_TYPE_FIELD] = "defaultdict"
+			result[DEFAULT_FACTORY_FIELD] = o.default_factory.__name__ if o.default_factory else None
+			return result
+
+		# Handle Node and Relation instances (already dataclasses but need special handling)
+		if isinstance(o, (Node, Relation)):
+			# Convert to dict with minimal information
+			return _serialize_instance(o)
+
+		# Handle NodeType and RelationType (dataclasses with parent references)
+		if isinstance(o, (NodeType, RelationType)):
+			result = asdict(o)
+			result[GRAPHITE_TYPE_FIELD] = type(o).__name__
+			# Convert parent to name reference to avoid circular references
+			if isinstance(o, NodeType) and o.parent:
+				result["parent"] = o.parent.name
+			# Remove type_ref from serialization
+			result.pop("type_ref", None)
+			return result
+
+		# Handle Field
+		if isinstance(o, Field):
+			result = asdict(o)
+			result[GRAPHITE_TYPE_FIELD] = "Field"
+			# Convert dtype to value
+			result["dtype"] = o.dtype.value
+			return result
+
+		# Handle dataclasses
+		if is_dataclass(o) and not isinstance(o, type):
+			# Convert to dict and add type info
+			result = asdict(o)
+			result[GRAPHITE_TYPE_FIELD] = type(o).__name__
+			return result
+
+		if isinstance(o, (dict, list)):
+			return o
+
+		return super().default(o)
+
+# pylint: disable=too-many-branches
+def graphite_object_hook(dct: dict[str, Any]) -> Any:  # pylint: disable=too-many-return-statements
+	"""Decode Graphite-specific objects from JSON."""
+	if GRAPHITE_TYPE_FIELD not in dct:
+		return dct
+
+	graphite_type = dct.pop(GRAPHITE_TYPE_FIELD)
+
+	if graphite_type == "datetime":
+		value = dct["value"]
+		if dct.get("is_date"):
+			return date.fromisoformat(value)
+		return datetime.fromisoformat(value)
+
+	if graphite_type == "enum":
+		enum_class = dct["enum_class"]
+		value = dct["value"]
+		if enum_class == "DataType":
+			return DataType(value)
+		return dct
+
+	if graphite_type == "datatype":
+		return DataType(dct["value"])
+
+	if graphite_type == "defaultdict":
+		factory_name = dct.pop(DEFAULT_FACTORY_FIELD, None)
+		factory: Union[Callable[[], Any], None] = None
+		if factory_name == "list":
+			factory = list
+		elif factory_name == "dict":
+			factory = dict
+		result = defaultdict(factory)
+		result.update(dct)
+		return result
+
+	if graphite_type == "Node":
+		return Node(
+			type_name=dct["type_name"],
+			id=dct["id"],
+			values=dct["values"],
+			type_ref=None
+		)
+
+	if graphite_type == "Relation":
+		return Relation(
+			type_name=dct["type_name"],
+			from_node=dct["from_node"],
+			to_node=dct["to_node"],
+			values=dct["values"],
+			type_ref=None
+		)
+
+	if graphite_type == "NodeType":
+		return {
+			"name": dct["name"],
+			"fields": dct.get("fields", []),
+			"parent": dct.get("parent")
+		}
+
+	if graphite_type == "RelationType":
+		return RelationType(
+			name=dct["name"],
+			from_type=dct["from_type"],
+			to_type=dct["to_type"],
+			fields=dct.get("fields", []),
+			reverse_name=dct.get("reverse_name"),
+			is_bidirectional=dct.get("is_bidirectional", False)
+		)
+
+	if graphite_type == "Field":
+		return Field(
+			name=dct["name"],
+			dtype=DataType(dct["dtype"]),
+			default=dct.get("default")
+		)
+
+	return dct