id
int64 0
328k
| repository_name
stringlengths 7
58
| file_path
stringlengths 9
302
| class_name
stringlengths 5
256
| human_written_code
stringlengths 16
2.16M
| class_skeleton
stringlengths 18
1.49M
⌀ | total_program_units
int64 1
1.76k
| total_doc_str
int64 0
771
| AvgCountLine
float64 0
7.89k
| AvgCountLineBlank
float64 0
297
| AvgCountLineCode
float64 0
7.89k
| AvgCountLineComment
float64 0
7.89k
| AvgCyclomatic
float64 0
130
| CommentToCodeRatio
float64 0
168
| CountClassBase
float64 0
40
| CountClassCoupled
float64 0
583
| CountClassCoupledModified
float64 0
575
| CountClassDerived
float64 0
5.35k
| CountDeclInstanceMethod
float64 0
529
| CountDeclInstanceVariable
float64 0
296
| CountDeclMethod
float64 0
599
| CountDeclMethodAll
float64 0
1.12k
| CountLine
float64 1
40.4k
| CountLineBlank
float64 0
8.16k
| CountLineCode
float64 1
25.7k
| CountLineCodeDecl
float64 1
8.15k
| CountLineCodeExe
float64 0
24.2k
| CountLineComment
float64 0
16.5k
| CountStmt
float64 1
9.71k
| CountStmtDecl
float64 1
8.15k
| CountStmtExe
float64 0
9.69k
| MaxCyclomatic
float64 0
759
| MaxInheritanceTree
float64 0
16
| MaxNesting
float64 0
34
| SumCyclomatic
float64 0
2.9k
|
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
328,000
|
gazorby/strawchemy
|
/Users/umroot/Documents/PhD_works/PhD-Core-Contents/Class-level-dataset-curation/unseen_data/git_repos_for_analysis/gazorby_strawchemy/src/strawchemy/strawberry/dto.py
|
strawchemy.strawberry.dto.EnumDTO
|
from typing import TYPE_CHECKING, Any, ClassVar, Generic, Literal, Optional, TypeVar, Union, overload
from enum import Enum
from strawchemy.dto.base import DTOBase, DTOFieldDefinition, ModelFieldT, ModelT
class EnumDTO(DTOBase[Any], Enum):
__field_definitions__: dict[str, GraphQLFieldDefinition]
@property
def field_definition(self) -> GraphQLFieldDefinition:
...
|
class EnumDTO(DTOBase[Any], Enum):
@property
def field_definition(self) -> GraphQLFieldDefinition:
pass
| 3
| 0
| 1
| 0
| 1
| 0
| 1
| 0
| 2
| 1
| 1
| 0
| 1
| 0
| 1
| 52
| 5
| 1
| 4
| 3
| 2
| 0
| 4
| 2
| 2
| 1
| 4
| 0
| 1
|
328,001
|
gazorby/strawchemy
|
/Users/umroot/Documents/PhD_works/PhD-Core-Contents/Class-level-dataset-curation/unseen_data/git_repos_for_analysis/gazorby_strawchemy/src/strawchemy/strawberry/dto.py
|
strawchemy.strawberry.dto.Filter
|
import dataclasses
from typing import TYPE_CHECKING, Any, ClassVar, Generic, Literal, Optional, TypeVar, Union, overload
from typing_extensions import Self, override
from dataclasses import dataclass
@dataclass
class Filter:
and_: list[Union[Union[Self, GraphQLComparison], AggregationFilter]] = dataclasses.field(default_factory=list)
or_: list[Self] = dataclasses.field(default_factory=list)
not_: Optional[Self] = None
def __bool__(self) -> bool:
return bool(self.and_ or self.or_ or self.not_)
|
@dataclass
class Filter:
def __bool__(self) -> bool:
pass
| 3
| 0
| 2
| 0
| 2
| 0
| 1
| 0
| 0
| 1
| 0
| 0
| 1
| 0
| 1
| 1
| 7
| 1
| 6
| 5
| 4
| 0
| 6
| 5
| 4
| 1
| 0
| 0
| 1
|
328,002
|
gazorby/strawchemy
|
/Users/umroot/Documents/PhD_works/PhD-Core-Contents/Class-level-dataset-curation/unseen_data/git_repos_for_analysis/gazorby_strawchemy/src/strawchemy/strawberry/dto.py
|
strawchemy.strawberry.dto.FilterFunctionInfo
|
from typing import TYPE_CHECKING, Any, ClassVar, Generic, Literal, Optional, TypeVar, Union, overload
from dataclasses import dataclass
@dataclass
class FilterFunctionInfo:
function: AggregationFunction
enum_fields: type[EnumDTO]
aggregation_type: AggregationType
comparison_type: type[GraphQLComparison]
require_arguments: bool = True
field_name_: Optional[str] = None
@property
def field_name(self) -> str:
if self.field_name_ is None:
return self.function
return self.field_name_
|
@dataclass
class FilterFunctionInfo:
@property
def field_name(self) -> str:
pass
| 4
| 0
| 4
| 0
| 4
| 0
| 2
| 0
| 0
| 1
| 0
| 0
| 1
| 0
| 1
| 1
| 14
| 2
| 12
| 5
| 9
| 0
| 11
| 4
| 9
| 2
| 0
| 1
| 2
|
328,003
|
gazorby/strawchemy
|
/Users/umroot/Documents/PhD_works/PhD-Core-Contents/Class-level-dataset-curation/unseen_data/git_repos_for_analysis/gazorby_strawchemy/src/strawchemy/strawberry/dto.py
|
strawchemy.strawberry.dto.FunctionArgFieldDefinition
|
from dataclasses import dataclass
@dataclass(eq=False, repr=False)
class FunctionArgFieldDefinition(FunctionFieldDefinition):
def __post_init__(self) -> None:
super().__post_init__()
self.is_function_arg = True
|
@dataclass(eq=False, repr=False)
class FunctionArgFieldDefinition(FunctionFieldDefinition):
def __post_init__(self) -> None:
pass
| 3
| 0
| 3
| 0
| 3
| 0
| 1
| 0
| 1
| 1
| 0
| 0
| 1
| 1
| 1
| 30
| 4
| 0
| 4
| 3
| 2
| 0
| 4
| 3
| 2
| 1
| 4
| 0
| 1
|
328,004
|
gazorby/strawchemy
|
/Users/umroot/Documents/PhD_works/PhD-Core-Contents/Class-level-dataset-curation/unseen_data/git_repos_for_analysis/gazorby_strawchemy/src/strawchemy/strawberry/dto.py
|
strawchemy.strawberry.dto.FunctionFieldDefinition
|
from strawchemy.dto.base import DTOBase, DTOFieldDefinition, ModelFieldT, ModelT
from typing import TYPE_CHECKING, Any, ClassVar, Generic, Literal, Optional, TypeVar, Union, overload
from typing_extensions import Self, override
from dataclasses import dataclass
@dataclass(eq=False, repr=False)
class FunctionFieldDefinition(GraphQLFieldDefinition):
is_relation: bool = False
def __post_init__(self) -> None:
super().__post_init__()
self.is_function = True
@override
@classmethod
def from_field(cls, field_def: DTOFieldDefinition[ModelT, ModelFieldT], *, function: Union[FilterFunctionInfo, OutputFunctionInfo], **kwargs: Any) -> Self:
return super().from_field(field_def, _function=function, **kwargs)
@override
def _hash_identity(self) -> Hashable:
return (super()._hash_identity(), self.function(strict=True).function, self.function(strict=True).require_arguments)
|
@dataclass(eq=False, repr=False)
class FunctionFieldDefinition(GraphQLFieldDefinition):
def __post_init__(self) -> None:
pass
@override
@classmethod
def from_field(cls, field_def: DTOFieldDefinition[ModelT, ModelFieldT], *, function: Union[FilterFunctionInfo, OutputFunctionInfo], **kwargs: Any) -> Self:
pass
@override
def _hash_identity(self) -> Hashable:
pass
| 8
| 0
| 6
| 0
| 6
| 0
| 1
| 0
| 1
| 5
| 2
| 1
| 2
| 1
| 3
| 29
| 25
| 3
| 22
| 14
| 9
| 0
| 9
| 6
| 5
| 1
| 3
| 0
| 3
|
328,005
|
gazorby/strawchemy
|
/Users/umroot/Documents/PhD_works/PhD-Core-Contents/Class-level-dataset-curation/unseen_data/git_repos_for_analysis/gazorby_strawchemy/src/strawchemy/strawberry/dto.py
|
strawchemy.strawberry.dto.GraphQLFieldDefinition
|
from sqlalchemy.orm import DeclarativeBase, QueryableAttribute
from typing import TYPE_CHECKING, Any, ClassVar, Generic, Literal, Optional, TypeVar, Union, overload
from dataclasses import dataclass
from typing_extensions import Self, override
from strawchemy.dto.base import DTOBase, DTOFieldDefinition, ModelFieldT, ModelT
import dataclasses
@dataclass(eq=False, repr=False)
class GraphQLFieldDefinition(DTOFieldDefinition[DeclarativeBase, QueryableAttribute[Any]]):
is_aggregate: bool = False
is_function: bool = False
is_function_arg: bool = False
_function: Optional[FunctionInfo] = None
def _hash_identity(self) -> Hashable:
return (self.model_identity, self.is_relation, self.init, self.uselist, self.model_field_name, self.is_aggregate, self.is_function, self.is_function_arg)
@classmethod
def from_field(cls, field_def: DTOFieldDefinition[ModelT, ModelFieldT], **kwargs: Any) -> Self:
return cls(**{dc_field.name: getattr(field_def, dc_field.name) for dc_field in dataclasses.fields(field_def) if dc_field.init} | kwargs)
@property
def is_computed(self) -> bool:
return self.is_function or self.is_function_arg or self.is_aggregate
@overload
def function(self, strict: Literal[False]) -> Optional[FunctionInfo]:
...
@overload
def function(self, strict: Literal[True]) -> FunctionInfo:
...
@overload
def function(self, strict: bool=False) -> Optional[FunctionInfo]:
...
def function(self, strict: bool=False) -> Optional[FunctionInfo]:
if not strict:
return self._function
if self._function is None:
msg = 'This node is not a function'
raise ValueError(msg)
return self._function
@override
def __hash__(self) -> int:
return hash(self._hash_identity())
@override
def __eq__(self, other: object) -> bool:
return hash(self) == hash(other)
@override
def __ne__(self, other: object) -> bool:
return hash(self) != hash(other)
|
@dataclass(eq=False, repr=False)
class GraphQLFieldDefinition(DTOFieldDefinition[DeclarativeBase, QueryableAttribute[Any]]):
def _hash_identity(self) -> Hashable:
pass
@classmethod
def from_field(cls, field_def: DTOFieldDefinition[ModelT, ModelFieldT], **kwargs: Any) -> Self:
pass
@property
def is_computed(self) -> bool:
pass
@overload
def function(self, strict: Literal[False]) -> Optional[FunctionInfo]:
pass
@overload
def function(self, strict: Literal[False]) -> Optional[FunctionInfo]:
pass
@overload
def function(self, strict: Literal[False]) -> Optional[FunctionInfo]:
pass
def function(self, strict: Literal[False]) -> Optional[FunctionInfo]:
pass
@override
def __hash__(self) -> int:
pass
@override
def __eq__(self, other: object) -> bool:
pass
@override
def __ne__(self, other: object) -> bool:
pass
| 20
| 0
| 4
| 0
| 4
| 0
| 1
| 0
| 1
| 6
| 0
| 2
| 9
| 0
| 10
| 26
| 62
| 11
| 51
| 24
| 35
| 0
| 30
| 16
| 19
| 3
| 2
| 1
| 12
|
328,006
|
gazorby/strawchemy
|
/Users/umroot/Documents/PhD_works/PhD-Core-Contents/Class-level-dataset-curation/unseen_data/git_repos_for_analysis/gazorby_strawchemy/src/strawchemy/strawberry/dto.py
|
strawchemy.strawberry.dto.GraphQLFilterDTO
|
from sqlalchemy.orm import DeclarativeBase, QueryableAttribute
import strawberry
class GraphQLFilterDTO(UnmappedStrawberryGraphQLDTO[DeclarativeBase]):
@property
def dto_set_fields(self) -> set[str]:
return {name for name in self.__dto_field_definitions__ if getattr(self, name) is not strawberry.UNSET}
|
class GraphQLFilterDTO(UnmappedStrawberryGraphQLDTO[DeclarativeBase]):
@property
def dto_set_fields(self) -> set[str]:
pass
| 3
| 0
| 2
| 0
| 2
| 0
| 1
| 0
| 1
| 2
| 0
| 3
| 1
| 0
| 1
| 3
| 4
| 0
| 4
| 3
| 1
| 0
| 3
| 2
| 1
| 1
| 4
| 0
| 1
|
328,007
|
gazorby/strawchemy
|
/Users/umroot/Documents/PhD_works/PhD-Core-Contents/Class-level-dataset-curation/unseen_data/git_repos_for_analysis/gazorby_strawchemy/src/strawchemy/strawberry/dto.py
|
strawchemy.strawberry.dto.MappedStrawberryGraphQLDTO
|
from strawchemy.dto.base import DTOBase, DTOFieldDefinition, ModelFieldT, ModelT
from strawchemy.dto.backend.strawberry import MappedStrawberryDTO, StrawberryDTO
class MappedStrawberryGraphQLDTO(StrawchemyDTOAttributes, MappedStrawberryDTO[ModelT]):
...
|
class MappedStrawberryGraphQLDTO(StrawchemyDTOAttributes, MappedStrawberryDTO[ModelT]):
pass
| 1
| 0
| 0
| 0
| 0
| 0
| 0
| 0
| 2
| 0
| 0
| 0
| 0
| 0
| 0
| 3
| 1
| 0
| 1
| 1
| 1
| 0
| 2
| 1
| 1
| 0
| 4
| 0
| 0
|
328,008
|
gazorby/strawchemy
|
/Users/umroot/Documents/PhD_works/PhD-Core-Contents/Class-level-dataset-curation/unseen_data/git_repos_for_analysis/gazorby_strawchemy/src/strawchemy/strawberry/dto.py
|
strawchemy.strawberry.dto.OrderByDTO
|
from typing import TYPE_CHECKING, Any, ClassVar, Generic, Literal, Optional, TypeVar, Union, overload
from .typing import GraphQLPurpose, OrderByDTOT, QueryNodeType
from msgspec import Struct, field, json
class OrderByDTO(GraphQLFilterDTO):
def tree(self, _node: Optional[QueryNodeType]=None) -> QueryNodeType:
node = _node or QueryNode.root_node(self.__dto_model__)
key = DTOKey.from_query_node(node)
for name in self.dto_set_fields:
value: Union[OrderByDTO, OrderByEnum] = getattr(self, name)
field = self.__strawchemy_field_map__[key + name]
if isinstance(field, FunctionFieldDefinition) and (not field.has_model_field):
field.model_field = node.value.model_field
if isinstance(value, OrderByDTO):
child, _ = node.upsert_child(field, match_on='value_equality')
value.tree(child)
else:
child = node.insert_child(field)
child.metadata.data.order_by = value
return node
|
class OrderByDTO(GraphQLFilterDTO):
def tree(self, _node: Optional[QueryNodeType]=None) -> QueryNodeType:
pass
| 2
| 0
| 16
| 1
| 15
| 0
| 4
| 0
| 1
| 4
| 4
| 0
| 1
| 0
| 1
| 4
| 17
| 1
| 16
| 8
| 14
| 0
| 15
| 8
| 13
| 4
| 5
| 2
| 4
|
328,009
|
gazorby/strawchemy
|
/Users/umroot/Documents/PhD_works/PhD-Core-Contents/Class-level-dataset-curation/unseen_data/git_repos_for_analysis/gazorby_strawchemy/src/strawchemy/strawberry/dto.py
|
strawchemy.strawberry.dto.OrderByEnum
|
from enum import Enum
class OrderByEnum(Enum):
ASC = 'ASC'
ASC_NULLS_FIRST = 'ASC_NULLS_FIRST'
ASC_NULLS_LAST = 'ASC_NULLS_LAST'
DESC = 'DESC'
DESC_NULLS_FIRST = 'DESC_NULLS_FIRST'
DESC_NULLS_LAST = 'DESC_NULLS_LAST'
|
class OrderByEnum(Enum):
pass
| 1
| 0
| 0
| 0
| 0
| 0
| 0
| 0
| 1
| 0
| 0
| 0
| 0
| 0
| 0
| 49
| 7
| 0
| 7
| 7
| 6
| 0
| 7
| 7
| 6
| 0
| 4
| 0
| 0
|
328,010
|
gazorby/strawchemy
|
/Users/umroot/Documents/PhD_works/PhD-Core-Contents/Class-level-dataset-curation/unseen_data/git_repos_for_analysis/gazorby_strawchemy/src/strawchemy/strawberry/dto.py
|
strawchemy.strawberry.dto.OrderByRelationFilterDTO
|
from typing import TYPE_CHECKING, Any, ClassVar, Generic, Literal, Optional, TypeVar, Union, overload
from typing_extensions import Self, override
from msgspec import Struct, field, json
from .typing import GraphQLPurpose, OrderByDTOT, QueryNodeType
class OrderByRelationFilterDTO(RelationFilterDTO, Generic[OrderByDTOT], frozen=True):
order_by: tuple[OrderByDTOT] = field(default_factory=tuple)
@override
def __bool__(self) -> bool:
return bool(self.limit or self.offset or self.order_by)
|
class OrderByRelationFilterDTO(RelationFilterDTO, Generic[OrderByDTOT], frozen=True):
@override
def __bool__(self) -> bool:
pass
| 3
| 0
| 2
| 0
| 2
| 0
| 1
| 0
| 3
| 1
| 0
| 0
| 1
| 0
| 1
| 31
| 6
| 1
| 5
| 4
| 2
| 0
| 4
| 3
| 2
| 1
| 3
| 0
| 1
|
328,011
|
gazorby/strawchemy
|
/Users/umroot/Documents/PhD_works/PhD-Core-Contents/Class-level-dataset-curation/unseen_data/git_repos_for_analysis/gazorby_strawchemy/src/strawchemy/strawberry/dto.py
|
strawchemy.strawberry.dto.OutputFunctionInfo
|
from strawchemy.dto.types import DTOConfig, DTOFieldConfig, DTOMissing, Purpose
from typing import TYPE_CHECKING, Any, ClassVar, Generic, Literal, Optional, TypeVar, Union, overload
from dataclasses import dataclass
@dataclass
class OutputFunctionInfo:
function: AggregationFunction
output_type: Any
require_arguments: bool = True
default: Any = DTOMissing
|
@dataclass
class OutputFunctionInfo:
pass
| 2
| 0
| 0
| 0
| 0
| 0
| 0
| 0
| 0
| 0
| 0
| 0
| 0
| 0
| 0
| 0
| 5
| 0
| 5
| 3
| 4
| 0
| 5
| 3
| 4
| 0
| 0
| 0
| 0
|
328,012
|
gazorby/strawchemy
|
/Users/umroot/Documents/PhD_works/PhD-Core-Contents/Class-level-dataset-curation/unseen_data/git_repos_for_analysis/gazorby_strawchemy/src/strawchemy/strawberry/dto.py
|
strawchemy.strawberry.dto.QueryGraphMetadata
|
from dataclasses import dataclass
@dataclass
class QueryGraphMetadata:
root_aggregations: bool = False
|
@dataclass
class QueryGraphMetadata:
pass
| 2
| 0
| 0
| 0
| 0
| 0
| 0
| 0
| 0
| 0
| 0
| 0
| 0
| 0
| 0
| 0
| 2
| 0
| 2
| 2
| 1
| 0
| 2
| 2
| 1
| 0
| 0
| 0
| 0
|
328,013
|
gazorby/strawchemy
|
/Users/umroot/Documents/PhD_works/PhD-Core-Contents/Class-level-dataset-curation/unseen_data/git_repos_for_analysis/gazorby_strawchemy/src/strawchemy/strawberry/dto.py
|
strawchemy.strawberry.dto.QueryNode
|
from dataclasses import dataclass
from strawchemy.utils import camel_to_snake
import dataclasses
from strawchemy.dto.types import DTOConfig, DTOFieldConfig, DTOMissing, Purpose
from typing_extensions import Self, override
from strawchemy.graph import AnyNode, GraphMetadata, MatchOn, Node, NodeMetadata, NodeT
from typing import TYPE_CHECKING, Any, ClassVar, Generic, Literal, Optional, TypeVar, Union, overload
from sqlalchemy.orm import DeclarativeBase, QueryableAttribute
@dataclass(eq=False)
class QueryNode(Node[GraphQLFieldDefinition, QueryNodeMetadata]):
node_metadata: Optional[NodeMetadata[QueryNodeMetadata]] = dataclasses.field(default_factory=lambda: NodeMetadata(QueryNodeMetadata()))
graph_metadata: GraphMetadata[QueryGraphMetadata] = dataclasses.field(default_factory=lambda: GraphMetadata(QueryGraphMetadata()))
@classmethod
@override
def _node_hash_identity(cls, node: Node[GraphQLFieldDefinition, QueryNodeMetadata]) -> Hashable:
return (super()._node_hash_identity(node), node.metadata.data.relation_filter)
@override
def _update_new_child(self, child: NodeT) -> NodeT:
super()._update_new_child(child)
if self.value.is_function:
child.value = FunctionArgFieldDefinition.from_field(child.value, function=self.value.function(strict=True))
return child
@override
@classmethod
def match_nodes(cls, left: AnyNode, right: AnyNode, match_on: Union[Callable[[AnyNode, AnyNode], bool], MatchOn]) -> bool:
if match_on == 'value_equality':
return left.value.model is right.value.model and left.value.model_field_name == right.value.model_field_name
return super(cls, cls).match_nodes(left, right, match_on)
@classmethod
def root_node(cls, model: type[DeclarativeBase], root_aggregations: bool=False, strawberry_type: Optional[type[Any]]=None) -> Self:
root_name = camel_to_snake(model.__name__)
field_def = GraphQLFieldDefinition(config=DTOFieldConfig(), dto_config=DTOConfig(Purpose.READ), model=model, model_field_name=root_name, is_relation=False, type_hint=model)
return cls(value=field_def, graph_metadata=GraphMetadata(QueryGraphMetadata(root_aggregations=root_aggregations)), node_metadata=NodeMetadata(QueryNodeMetadata(strawberry_type=strawberry_type)))
@override
def __repr__(self) -> str:
return f'<{self.__class__.__name__} {self.value.model_field_name}>'
|
@dataclass(eq=False)
class QueryNode(Node[GraphQLFieldDefinition, QueryNodeMetadata]):
@classmethod
@override
def _node_hash_identity(cls, node: Node[GraphQLFieldDefinition, QueryNodeMetadata]) -> Hashable:
pass
@override
def _update_new_child(self, child: NodeT) -> NodeT:
pass
@override
@classmethod
def match_nodes(cls, left: AnyNode, right: AnyNode, match_on: Union[Callable[[AnyNode, AnyNode], bool], MatchOn]) -> bool:
pass
@classmethod
def root_node(cls, model: type[DeclarativeBase], root_aggregations: bool=False, strawberry_type: Optional[type[Any]]=None) -> Self:
pass
@override
def __repr__(self) -> str:
pass
| 14
| 0
| 8
| 0
| 8
| 0
| 1
| 0
| 1
| 16
| 9
| 1
| 2
| 0
| 5
| 43
| 57
| 5
| 52
| 25
| 29
| 0
| 20
| 10
| 14
| 2
| 2
| 1
| 7
|
328,014
|
gazorby/strawchemy
|
/Users/umroot/Documents/PhD_works/PhD-Core-Contents/Class-level-dataset-curation/unseen_data/git_repos_for_analysis/gazorby_strawchemy/src/strawchemy/strawberry/dto.py
|
strawchemy.strawberry.dto.QueryNodeMetadata
|
import dataclasses
from dataclasses import dataclass
from typing import TYPE_CHECKING, Any, ClassVar, Generic, Literal, Optional, TypeVar, Union, overload
@dataclass
class QueryNodeMetadata:
relation_filter: RelationFilterDTO = dataclasses.field(default_factory=RelationFilterDTO)
order_by: Optional[OrderByEnum] = None
strawberry_type: Optional[type[Any]] = None
json_path: Optional[str] = None
@property
def is_transform(self) -> bool:
return bool(self.json_path)
|
@dataclass
class QueryNodeMetadata:
@property
def is_transform(self) -> bool:
pass
| 4
| 0
| 2
| 0
| 2
| 0
| 1
| 0
| 0
| 1
| 0
| 0
| 1
| 0
| 1
| 1
| 9
| 1
| 8
| 7
| 5
| 0
| 7
| 6
| 5
| 1
| 0
| 0
| 1
|
328,015
|
gazorby/strawchemy
|
/Users/umroot/Documents/PhD_works/PhD-Core-Contents/Class-level-dataset-curation/unseen_data/git_repos_for_analysis/gazorby_strawchemy/src/strawchemy/strawberry/dto.py
|
strawchemy.strawberry.dto.RelationFilterDTO
|
from typing_extensions import Self, override
from msgspec import Struct, field, json
from functools import cached_property
from typing import TYPE_CHECKING, Any, ClassVar, Generic, Literal, Optional, TypeVar, Union, overload
class RelationFilterDTO(Struct, frozen=True, dict=True):
limit: Optional[int] = None
offset: Optional[int] = None
@cached_property
def _json(self) -> bytes:
return json.encode(self)
def __bool__(self) -> bool:
return bool(self.limit or self.offset)
@override
def __hash__(self) -> int:
return hash(self._json)
|
class RelationFilterDTO(Struct, frozen=True, dict=True):
@cached_property
def _json(self) -> bytes:
pass
def __bool__(self) -> bool:
pass
@override
def __hash__(self) -> int:
pass
| 6
| 0
| 2
| 0
| 2
| 0
| 1
| 0
| 3
| 3
| 0
| 1
| 3
| 0
| 3
| 30
| 14
| 3
| 11
| 8
| 5
| 0
| 9
| 6
| 5
| 1
| 2
| 0
| 3
|
328,016
|
gazorby/strawchemy
|
/Users/umroot/Documents/PhD_works/PhD-Core-Contents/Class-level-dataset-curation/unseen_data/git_repos_for_analysis/gazorby_strawchemy/src/strawchemy/strawberry/dto.py
|
strawchemy.strawberry.dto.StrawchemyDTOAttributes
|
from typing import TYPE_CHECKING, Any, ClassVar, Generic, Literal, Optional, TypeVar, Union, overload
from strawchemy.sqlalchemy.hook import QueryHook
from .typing import GraphQLPurpose, OrderByDTOT, QueryNodeType
class StrawchemyDTOAttributes:
__strawchemy_description__: ClassVar[str] = 'GraphQL type'
__strawchemy_is_root_aggregation_type__: ClassVar[bool] = False
__strawchemy_field_map__: ClassVar[dict[DTOKey, GraphQLFieldDefinition]] = {}
__strawchemy_query_hook__: ClassVar[Optional[Union[QueryHook[Any], list[QueryHook[Any]]]]] = None
__strawchemy_filter__: ClassVar[Optional[type[Any]]] = None
__strawchemy_order_by__: ClassVar[Optional[type[Any]]] = None
__strawchemy_purpose__: ClassVar[Optional[GraphQLPurpose]] = None
|
class StrawchemyDTOAttributes:
pass
| 1
| 0
| 0
| 0
| 0
| 0
| 0
| 0
| 0
| 0
| 0
| 4
| 0
| 0
| 0
| 0
| 8
| 0
| 8
| 8
| 7
| 0
| 8
| 8
| 7
| 0
| 0
| 0
| 0
|
328,017
|
gazorby/strawchemy
|
/Users/umroot/Documents/PhD_works/PhD-Core-Contents/Class-level-dataset-curation/unseen_data/git_repos_for_analysis/gazorby_strawchemy/src/strawchemy/strawberry/dto.py
|
strawchemy.strawberry.dto.UnmappedStrawberryGraphQLDTO
|
from strawchemy.dto.base import DTOBase, DTOFieldDefinition, ModelFieldT, ModelT
from strawchemy.dto.backend.strawberry import MappedStrawberryDTO, StrawberryDTO
class UnmappedStrawberryGraphQLDTO(StrawchemyDTOAttributes, StrawberryDTO[ModelT]):
...
|
class UnmappedStrawberryGraphQLDTO(StrawchemyDTOAttributes, StrawberryDTO[ModelT]):
pass
| 1
| 0
| 0
| 0
| 0
| 0
| 0
| 0
| 2
| 0
| 0
| 3
| 0
| 0
| 0
| 2
| 1
| 0
| 1
| 1
| 1
| 0
| 2
| 1
| 1
| 0
| 3
| 0
| 0
|
328,018
|
gazorby/strawchemy
|
/Users/umroot/Documents/PhD_works/PhD-Core-Contents/Class-level-dataset-curation/unseen_data/git_repos_for_analysis/gazorby_strawchemy/src/strawchemy/strawberry/dto.py
|
strawchemy.strawberry.dto._ArgumentValue
|
from strawchemy.dto.base import DTOBase, DTOFieldDefinition, ModelFieldT, ModelT
from typing import TYPE_CHECKING, Any, ClassVar, Generic, Literal, Optional, TypeVar, Union, overload
from sqlalchemy.orm import DeclarativeBase, QueryableAttribute
class _ArgumentValue:
__field_definitions__: ClassVar[dict[str, DTOFieldDefinition[DeclarativeBase, QueryableAttribute[Any]]]]
value: str
|
class _ArgumentValue:
pass
| 1
| 0
| 0
| 0
| 0
| 0
| 0
| 0
| 0
| 0
| 0
| 0
| 0
| 0
| 0
| 0
| 4
| 1
| 3
| 1
| 2
| 0
| 3
| 1
| 2
| 0
| 0
| 0
| 0
|
328,019
|
gazorby/strawchemy
|
/Users/umroot/Documents/PhD_works/PhD-Core-Contents/Class-level-dataset-curation/unseen_data/git_repos_for_analysis/gazorby_strawchemy/src/strawchemy/strawberry/dto.py
|
strawchemy.strawberry.dto._Key
|
from typing import TYPE_CHECKING, Any, ClassVar, Generic, Literal, Optional, TypeVar, Union, overload
from typing_extensions import Self, override
class _Key(Generic[T]):
"""A class to represent a key with multiple components.
The key is a sequence of components joined by a separator (default: ":").
It can be constructed from a sequence of components or a single string.
Components can be of any type, but must be convertible to a string.
The key can be extended with additional components using the `extend` or
`append` methods. The key can also be concatenated with another key or a
string using the `+` operator.
The key can be converted to a string using the `str` function or the
`to_str` method.
Subclasses should implement the `to_str` method to convert a component to a
string.
"""
separator: str = ':'
def __init__(self, components: Optional[Union[Sequence[Union[T, str]], str]]=None) -> None:
self._key: str = ''
if isinstance(components, str):
self._key = components
elif components:
self._key = str(self.extend(components))
def _components_to_str(self, objects: Sequence[Union[T, str]]) -> Sequence[str]:
return [obj if isinstance(obj, str) else self.to_str(obj) for obj in objects]
def to_str(self, obj: T) -> str:
raise NotImplementedError
def append(self, component: Union[T, str]) -> Self:
return self.extend([component])
def extend(self, components: Sequence[Union[T, str]]) -> Self:
str_components = self._components_to_str(components)
self._key = self.separator.join([self._key, *str_components] if self._key else str_components)
return self
def __add__(self, other: Union[Self, str]) -> Self:
if isinstance(other, str):
return self.__class__((self._key, other))
return self.__class__((self._key, other._key))
@override
def __str__(self) -> str:
return self._key
@override
def __hash__(self) -> int:
return hash(str(self))
@override
def __eq__(self, other: object) -> bool:
return hash(self) == hash(other)
@override
def __ne__(self, other: object) -> bool:
return hash(self) != hash(other)
|
class _Key(Generic[T]):
'''A class to represent a key with multiple components.
The key is a sequence of components joined by a separator (default: ":").
It can be constructed from a sequence of components or a single string.
Components can be of any type, but must be convertible to a string.
The key can be extended with additional components using the `extend` or
`append` methods. The key can also be concatenated with another key or a
string using the `+` operator.
The key can be converted to a string using the `str` function or the
`to_str` method.
Subclasses should implement the `to_str` method to convert a component to a
string.
'''
def __init__(self, components: Optional[Union[Sequence[Union[T, str]], str]]=None) -> None:
pass
def _components_to_str(self, objects: Sequence[Union[T, str]]) -> Sequence[str]:
pass
def to_str(self, obj: T) -> str:
pass
def append(self, component: Union[T, str]) -> Self:
pass
def extend(self, components: Sequence[Union[T, str]]) -> Self:
pass
def __add__(self, other: Union[Self, str]) -> Self:
pass
@override
def __str__(self) -> str:
pass
@override
def __hash__(self) -> int:
pass
@override
def __eq__(self, other: object) -> bool:
pass
@override
def __ne__(self, other: object) -> bool:
pass
| 15
| 1
| 3
| 0
| 3
| 0
| 2
| 0.35
| 1
| 6
| 0
| 1
| 10
| 1
| 10
| 10
| 61
| 15
| 34
| 18
| 19
| 12
| 29
| 14
| 18
| 3
| 1
| 1
| 15
|
328,020
|
gazorby/strawchemy
|
/Users/umroot/Documents/PhD_works/PhD-Core-Contents/Class-level-dataset-curation/unseen_data/git_repos_for_analysis/gazorby_strawchemy/src/strawchemy/strawberry/exceptions.py
|
strawchemy.strawberry.exceptions.StrawchemyFieldError
|
class StrawchemyFieldError(Exception):
...
|
class StrawchemyFieldError(Exception):
pass
| 1
| 0
| 0
| 0
| 0
| 0
| 0
| 0
| 1
| 0
| 0
| 0
| 0
| 0
| 0
| 10
| 1
| 0
| 1
| 1
| 1
| 0
| 2
| 1
| 1
| 0
| 3
| 0
| 0
|
328,021
|
gazorby/strawchemy
|
/Users/umroot/Documents/PhD_works/PhD-Core-Contents/Class-level-dataset-curation/unseen_data/git_repos_for_analysis/gazorby_strawchemy/src/strawchemy/strawberry/factories/aggregations.py
|
strawchemy.strawberry.factories.aggregations.AggregationInspector
|
from strawchemy.strawberry.dto import DTOKey, EnumDTO, FilterFunctionInfo, FunctionArgFieldDefinition, GraphQLFieldDefinition, OutputFunctionInfo, UnmappedStrawberryGraphQLDTO
from functools import cached_property
from sqlalchemy.orm import DeclarativeBase
from strawchemy.dto.exceptions import DTOError
from typing import TYPE_CHECKING, Any, ClassVar, Optional, TypeVar, cast
from datetime import date, datetime, time, timedelta
class AggregationInspector:
def __init__(self, mapper: Strawchemy) -> None:
self._inspector = mapper.config.inspector
self._count_fields_factory = _CountFieldsDTOFactory(self._inspector)
self._numeric_fields_factory = _NumericFieldsDTOFactory(mapper)
self._sum_fields_factory = _SumFieldsDTOFactory(mapper)
self._min_max_numeric_fields_factory = _MinMaxNumericFieldsDTOFactory(mapper)
self._min_max_datetime_fields_factory = _MinMaxDateTimeFieldsDTOFactory(mapper)
self._min_max_date_fields_factory = _MinMaxDateFieldsDTOFactory(mapper)
self._min_max_string_fields_factory = _MinMaxStringFieldsDTOFactory(mapper)
self._min_max_time_fields_factory = _MinMaxTimeFieldsDTOFactory(mapper)
self._min_max_fields_factory = _MinMaxFieldsDTOFactory(mapper)
def _supports_aggregations(self, *function: AggregationFunction) -> bool:
return set(function).issubset(self._inspector.db_features.aggregation_functions)
@cached_property
def _statistical_aggregations(self) -> list[AggregationFunction]:
return list(self._inspector.db_features.aggregation_functions - cast('set[AggregationFunction]', {'min', 'max', 'sum', 'count'}))
def _min_max_filters(self, model: type[Any], dto_config: DTOConfig) -> list[FilterFunctionInfo]:
aggregations: list[FilterFunctionInfo] = []
if (min_max_numeric_fields := self.arguments_type(model, dto_config, 'min_max_numeric')):
aggregations.extend((FilterFunctionInfo(enum_fields=min_max_numeric_fields, function='min', aggregation_type='numeric', comparison_type=self._inspector.get_type_comparison(float)), FilterFunctionInfo(enum_fields=min_max_numeric_fields, function='max', aggregation_type='numeric', comparison_type=self._inspector.get_type_comparison(float))))
if (min_max_datetime_fields := self.arguments_type(model, dto_config, 'min_max_datetime')):
aggregations.extend((FilterFunctionInfo(enum_fields=min_max_datetime_fields, function='min', aggregation_type='min_max_datetime', comparison_type=self._inspector.get_type_comparison(datetime), field_name_='min_datetime'), FilterFunctionInfo(enum_fields=min_max_datetime_fields, function='max', aggregation_type='min_max_datetime', comparison_type=self._inspector.get_type_comparison(datetime), field_name_='max_datetime')))
if (min_max_date_fields := self.arguments_type(model, dto_config, 'min_max_date')):
aggregations.extend((FilterFunctionInfo(enum_fields=min_max_date_fields, function='min', aggregation_type='min_max_date', comparison_type=self._inspector.get_type_comparison(date), field_name_='min_date'), FilterFunctionInfo(enum_fields=min_max_date_fields, function='max', aggregation_type='min_max_date', comparison_type=self._inspector.get_type_comparison(date), field_name_='max_date')))
if (min_max_time_fields := self.arguments_type(model, dto_config, 'min_max_time')):
aggregations.extend((FilterFunctionInfo(enum_fields=min_max_time_fields, function='min', aggregation_type='min_max_time', comparison_type=self._inspector.get_type_comparison(time), field_name_='min_time'), FilterFunctionInfo(enum_fields=min_max_time_fields, function='max', aggregation_type='min_max_time', comparison_type=self._inspector.get_type_comparison(time), field_name_='max_time')))
if (min_max_string_fields := self.arguments_type(model, dto_config, 'min_max_string')):
aggregations.extend((FilterFunctionInfo(enum_fields=min_max_string_fields, function='min', aggregation_type='min_max_string', comparison_type=self._inspector.get_type_comparison(str), field_name_='min_string'), FilterFunctionInfo(enum_fields=min_max_string_fields, function='max', aggregation_type='min_max_string', comparison_type=self._inspector.get_type_comparison(str), field_name_='max_string')))
return aggregations
def arguments_type(self, model: type[DeclarativeBase], dto_config: DTOConfig, aggregation: AggregationType) -> Optional[type[EnumDTO]]:
try:
if aggregation == 'numeric':
dto = self._numeric_fields_factory.enum_factory(model, dto_config, raise_if_no_fields=True)
elif aggregation == 'sum':
dto = self._sum_fields_factory.enum_factory(model, dto_config, raise_if_no_fields=True)
elif aggregation == 'min_max_date':
dto = self._min_max_date_fields_factory.enum_factory(model, dto_config, raise_if_no_fields=True)
elif aggregation == 'min_max_datetime':
dto = self._min_max_datetime_fields_factory.enum_factory(model, dto_config, raise_if_no_fields=True)
elif aggregation == 'min_max_string':
dto = self._min_max_string_fields_factory.enum_factory(model, dto_config, raise_if_no_fields=True)
elif aggregation == 'min_max_numeric':
dto = self._min_max_numeric_fields_factory.enum_factory(model, dto_config, raise_if_no_fields=True)
elif aggregation == 'min_max_time':
dto = self._min_max_time_fields_factory.enum_factory(model, dto_config, raise_if_no_fields=True)
except DTOError:
return None
return dto
def numeric_field_type(self, model: type[DeclarativeBase], dto_config: DTOConfig) -> Optional[type[UnmappedStrawberryGraphQLDTO[DeclarativeBase]]]:
try:
dto = self._numeric_fields_factory.factory(model=model, dto_config=dto_config, raise_if_no_fields=True)
except DTOError:
return None
return dto
def min_max_field_type(self, model: type[DeclarativeBase], dto_config: DTOConfig) -> Optional[type[UnmappedStrawberryGraphQLDTO[DeclarativeBase]]]:
try:
dto = self._min_max_fields_factory.factory(model=model, dto_config=dto_config, raise_if_no_fields=True)
except DTOError:
return None
return dto
def sum_field_type(self, model: type[DeclarativeBase], dto_config: DTOConfig) -> Optional[type[UnmappedStrawberryGraphQLDTO[DeclarativeBase]]]:
try:
dto = self._sum_fields_factory.factory(model=model, dto_config=dto_config, raise_if_no_fields=True)
except DTOError:
return None
return dto
def output_functions(self, model: type[Any], dto_config: DTOConfig) -> list[OutputFunctionInfo]:
int_as_float_config = dto_config.copy_with(type_overrides={int: Optional[float], Optional[int]: Optional[float]})
numeric_fields = self.numeric_field_type(model, int_as_float_config)
aggregations: list[OutputFunctionInfo] = []
if self._supports_aggregations('count'):
aggregations.append(OutputFunctionInfo(function='count', require_arguments=False, output_type=Optional[int] if dto_config.partial else int))
if self._supports_aggregations('sum') and (sum_fields := self.sum_field_type(model, dto_config)):
aggregations.append(OutputFunctionInfo(function='sum', output_type=sum_fields))
if self._supports_aggregations('min', 'max') and (min_max_fields := self.min_max_field_type(model, dto_config)):
aggregations.extend([OutputFunctionInfo(function='min', output_type=min_max_fields), OutputFunctionInfo(function='max', output_type=min_max_fields)])
if numeric_fields:
aggregations.extend([OutputFunctionInfo(function=function, output_type=numeric_fields) for function in self._statistical_aggregations])
return sorted(aggregations, key=lambda aggregation: aggregation.function)
def filter_functions(self, model: type[Any], dto_config: DTOConfig) -> list[FilterFunctionInfo]:
count_fields = self._count_fields_factory.factory(model=model, dto_config=dto_config)
numeric_arg_fields = self.arguments_type(model, dto_config, 'numeric')
sum_arg_fields = self.arguments_type(model, dto_config, 'sum')
aggregations: list[FilterFunctionInfo] = []
if self._supports_aggregations('count'):
aggregations.append(FilterFunctionInfo(enum_fields=count_fields, function='count', aggregation_type='numeric', comparison_type=self._inspector.get_type_comparison(int), require_arguments=False))
if self._supports_aggregations('sum') and sum_arg_fields:
aggregations.append(FilterFunctionInfo(enum_fields=sum_arg_fields, function='sum', aggregation_type='numeric', comparison_type=self._inspector.get_type_comparison(float)))
if self._supports_aggregations('min', 'max'):
aggregations.extend(self._min_max_filters(model, dto_config))
if numeric_arg_fields:
comparison = self._inspector.get_type_comparison(float)
aggregations.extend([FilterFunctionInfo(enum_fields=numeric_arg_fields, function=function, aggregation_type='numeric', comparison_type=comparison) for function in self._statistical_aggregations])
return sorted(aggregations, key=lambda aggregation: aggregation.function)
|
class AggregationInspector:
def __init__(self, mapper: Strawchemy) -> None:
pass
def _supports_aggregations(self, *function: AggregationFunction) -> bool:
pass
@cached_property
def _statistical_aggregations(self) -> list[AggregationFunction]:
pass
def _min_max_filters(self, model: type[Any], dto_config: DTOConfig) -> list[FilterFunctionInfo]:
pass
def arguments_type(self, model: type[DeclarativeBase], dto_config: DTOConfig, aggregation: AggregationType) -> Optional[type[EnumDTO]]:
pass
def numeric_field_type(self, model: type[DeclarativeBase], dto_config: DTOConfig) -> Optional[type[UnmappedStrawberryGraphQLDTO[DeclarativeBase]]]:
pass
def min_max_field_type(self, model: type[DeclarativeBase], dto_config: DTOConfig) -> Optional[type[UnmappedStrawberryGraphQLDTO[DeclarativeBase]]]:
pass
def sum_field_type(self, model: type[DeclarativeBase], dto_config: DTOConfig) -> Optional[type[UnmappedStrawberryGraphQLDTO[DeclarativeBase]]]:
pass
def output_functions(self, model: type[Any], dto_config: DTOConfig) -> list[OutputFunctionInfo]:
pass
def filter_functions(self, model: type[Any], dto_config: DTOConfig) -> list[FilterFunctionInfo]:
pass
| 12
| 0
| 24
| 1
| 23
| 0
| 4
| 0
| 0
| 27
| 16
| 0
| 10
| 10
| 10
| 10
| 248
| 16
| 232
| 50
| 212
| 0
| 88
| 34
| 77
| 9
| 0
| 2
| 35
|
328,022
|
gazorby/strawchemy
|
/Users/umroot/Documents/PhD_works/PhD-Core-Contents/Class-level-dataset-curation/unseen_data/git_repos_for_analysis/gazorby_strawchemy/src/strawchemy/strawberry/factories/aggregations.py
|
strawchemy.strawberry.factories.aggregations._CountFieldsDTOFactory
|
from typing import TYPE_CHECKING, Any, ClassVar, Optional, TypeVar, cast
from typing_extensions import override
from .enum import EnumDTOBackend, EnumDTOFactory
from strawchemy.strawberry.dto import DTOKey, EnumDTO, FilterFunctionInfo, FunctionArgFieldDefinition, GraphQLFieldDefinition, OutputFunctionInfo, UnmappedStrawberryGraphQLDTO
class _CountFieldsDTOFactory(EnumDTOFactory):
@override
def dto_name(self, base_name: str, dto_config: DTOConfig, node: Optional[Node[Relation[Any, EnumDTO], None]]=None) -> str:
return f'{base_name}CountFields'
|
class _CountFieldsDTOFactory(EnumDTOFactory):
@override
def dto_name(self, base_name: str, dto_config: DTOConfig, node: Optional[Node[Relation[Any, EnumDTO], None]]=None) -> str:
pass
| 3
| 0
| 4
| 0
| 4
| 0
| 1
| 0
| 1
| 6
| 4
| 0
| 1
| 0
| 1
| 23
| 6
| 0
| 6
| 5
| 1
| 0
| 3
| 2
| 1
| 1
| 3
| 0
| 1
|
328,023
|
gazorby/strawchemy
|
/Users/umroot/Documents/PhD_works/PhD-Core-Contents/Class-level-dataset-curation/unseen_data/git_repos_for_analysis/gazorby_strawchemy/src/strawchemy/strawberry/factories/aggregations.py
|
strawchemy.strawberry.factories.aggregations._FunctionArgDTOFactory
|
from typing import TYPE_CHECKING, Any, ClassVar, Optional, TypeVar, cast
from strawchemy.dto.backend.strawberry import StrawberrryDTOBackend
from .enum import EnumDTOBackend, EnumDTOFactory
from typing_extensions import override
from .base import GraphQLDTOFactory
from strawchemy.strawberry.dto import DTOKey, EnumDTO, FilterFunctionInfo, FunctionArgFieldDefinition, GraphQLFieldDefinition, OutputFunctionInfo, UnmappedStrawberryGraphQLDTO
from sqlalchemy.orm import DeclarativeBase
class _FunctionArgDTOFactory(GraphQLDTOFactory[UnmappedStrawberryGraphQLDTO[DeclarativeBase]]):
types: ClassVar[set[type[Any]]] = set()
def __init__(self, mapper: Strawchemy, backend: Optional[DTOBackend[UnmappedStrawberryGraphQLDTO[DeclarativeBase]]]=None, handle_cycles: bool=True, type_map: Optional[dict[Any, Any]]=None) -> None:
super().__init__(mapper, backend or StrawberrryDTOBackend(UnmappedStrawberryGraphQLDTO), handle_cycles, type_map)
self._enum_backend = EnumDTOBackend()
@override
def should_exclude_field(self, field: DTOFieldDefinition[Any, QueryableAttribute[Any]], dto_config: DTOConfig, node: Node[Relation[Any, UnmappedStrawberryGraphQLDTO[DeclarativeBase]], None], has_override: bool=False) -> bool:
return super().should_exclude_field(field, dto_config, node, has_override) or field.is_relation or self.inspector.model_field_type(field) not in self.types
@override
def iter_field_definitions(self, name: str, model: type[DeclarativeT], dto_config: DTOConfig, base: Optional[type[DTOBase[DeclarativeBase]]], node: Node[Relation[DeclarativeBase, UnmappedStrawberryGraphQLDTO[DeclarativeBase]], None], raise_if_no_fields: bool=False, *, field_map: Optional[dict[DTOKey, GraphQLFieldDefinition]]=None, function: Optional[FunctionInfo]=None, **kwargs: Any) -> Generator[DTOFieldDefinition[DeclarativeBase, QueryableAttribute[Any]], None, None]:
for field in super().iter_field_definitions(name, model, dto_config, base, node, raise_if_no_fields, field_map=field_map, **kwargs):
yield (FunctionArgFieldDefinition.from_field(field, function=function) if function is not None else field)
@override
def factory(self, model: type[DeclarativeT], dto_config: DTOConfig, base: Optional[type[Any]]=None, name: Optional[str]=None, parent_field_def: Optional[DTOFieldDefinition[DeclarativeBase, QueryableAttribute[Any]]]=None, current_node: Optional[Node[Relation[Any, UnmappedStrawberryGraphQLDTO[DeclarativeBase]], None]]=None, raise_if_no_fields: bool=False, tags: Optional[set[str]]=None, backend_kwargs: Optional[dict[str, Any]]=None, *, function: Optional[FunctionInfo]=None, **kwargs: Any) -> type[UnmappedStrawberryGraphQLDTO[DeclarativeBase]]:
return super().factory(model, dto_config, base, name, parent_field_def, current_node, raise_if_no_fields, tags, backend_kwargs, function=function, **kwargs)
def enum_factory(self, model: type[DeclarativeT], dto_config: DTOConfig, name: Optional[str]=None, base: Optional[type[Any]]=None, raise_if_no_fields: bool=False, **kwargs: Any) -> type[EnumDTO]:
if not name:
name = f'{self.dto_name(model.__name__, dto_config)}Enum'
field_defs = self.iter_field_definitions(name=name, model=model, dto_config=dto_config, base=base, node=self._node_or_root(model, name, None), raise_if_no_fields=raise_if_no_fields, **kwargs)
return self._enum_backend.build(name, model, list(field_defs), base)
|
class _FunctionArgDTOFactory(GraphQLDTOFactory[UnmappedStrawberryGraphQLDTO[DeclarativeBase]]):
def __init__(self, mapper: Strawchemy, backend: Optional[DTOBackend[UnmappedStrawberryGraphQLDTO[DeclarativeBase]]]=None, handle_cycles: bool=True, type_map: Optional[dict[Any, Any]]=None) -> None:
pass
@override
def should_exclude_field(self, field: DTOFieldDefinition[Any, QueryableAttribute[Any]], dto_config: DTOConfig, node: Node[Relation[Any, UnmappedStrawberryGraphQLDTO[DeclarativeBase]], None], has_override: bool=False) -> bool:
pass
@override
def iter_field_definitions(self, name: str, model: type[DeclarativeT], dto_config: DTOConfig, base: Optional[type[DTOBase[DeclarativeBase]]], node: Node[Relation[DeclarativeBase, UnmappedStrawberryGraphQLDTO[DeclarativeBase]], None], raise_if_no_fields: bool=False, *, field_map: Optional[dict[DTOKey, GraphQLFieldDefinition]]=None, function: Optional[FunctionInfo]=None, **kwargs: Any) -> Generator[DTOFieldDefinition[DeclarativeBase, QueryableAttribute[Any]], None, None]:
pass
@override
def factory(self, model: type[DeclarativeT], dto_config: DTOConfig, base: Optional[type[Any]]=None, name: Optional[str]=None, parent_field_def: Optional[DTOFieldDefinition[DeclarativeBase, QueryableAttribute[Any]]]=None, current_node: Optional[Node[Relation[Any, UnmappedStrawberryGraphQLDTO[DeclarativeBase]], None]]=None, raise_if_no_fields: bool=False, tags: Optional[set[str]]=None, backend_kwargs: Optional[dict[str, Any]]=None, *, function: Optional[FunctionInfo]=None, **kwargs: Any) -> type[UnmappedStrawberryGraphQLDTO[DeclarativeBase]]:
pass
def enum_factory(self, model: type[DeclarativeT], dto_config: DTOConfig, name: Optional[str]=None, base: Optional[type[Any]]=None, raise_if_no_fields: bool=False, **kwargs: Any) -> type[EnumDTO]:
pass
| 9
| 0
| 17
| 0
| 17
| 0
| 2
| 0
| 1
| 22
| 14
| 8
| 5
| 1
| 5
| 35
| 97
| 5
| 92
| 58
| 38
| 0
| 17
| 10
| 11
| 3
| 3
| 1
| 8
|
328,024
|
gazorby/strawchemy
|
/Users/umroot/Documents/PhD_works/PhD-Core-Contents/Class-level-dataset-curation/unseen_data/git_repos_for_analysis/gazorby_strawchemy/src/strawchemy/strawberry/factories/aggregations.py
|
strawchemy.strawberry.factories.aggregations._MinMaxDateFieldsDTOFactory
|
from strawchemy.strawberry.dto import DTOKey, EnumDTO, FilterFunctionInfo, FunctionArgFieldDefinition, GraphQLFieldDefinition, OutputFunctionInfo, UnmappedStrawberryGraphQLDTO
from typing import TYPE_CHECKING, Any, ClassVar, Optional, TypeVar, cast
from datetime import date, datetime, time, timedelta
from typing_extensions import override
class _MinMaxDateFieldsDTOFactory(_FunctionArgDTOFactory):
types: ClassVar[set[type[Any]]] = {date}
@override
def dto_name(self, base_name: str, dto_config: DTOConfig, node: Optional[Node[Relation[Any, UnmappedStrawberryGraphQLDTO[ModelT]], None]]=None) -> str:
return f'{base_name}MinMaxDateFields'
|
class _MinMaxDateFieldsDTOFactory(_FunctionArgDTOFactory):
@override
def dto_name(self, base_name: str, dto_config: DTOConfig, node: Optional[Node[Relation[Any, UnmappedStrawberryGraphQLDTO[ModelT]], None]]=None) -> str:
pass
| 3
| 0
| 7
| 0
| 7
| 0
| 1
| 0
| 1
| 6
| 4
| 0
| 1
| 0
| 1
| 36
| 11
| 1
| 10
| 9
| 2
| 0
| 4
| 3
| 2
| 1
| 4
| 0
| 1
|
328,025
|
gazorby/strawchemy
|
/Users/umroot/Documents/PhD_works/PhD-Core-Contents/Class-level-dataset-curation/unseen_data/git_repos_for_analysis/gazorby_strawchemy/src/strawchemy/strawberry/factories/aggregations.py
|
strawchemy.strawberry.factories.aggregations._MinMaxDateTimeFieldsDTOFactory
|
from strawchemy.strawberry.dto import DTOKey, EnumDTO, FilterFunctionInfo, FunctionArgFieldDefinition, GraphQLFieldDefinition, OutputFunctionInfo, UnmappedStrawberryGraphQLDTO
from datetime import date, datetime, time, timedelta
from typing_extensions import override
from typing import TYPE_CHECKING, Any, ClassVar, Optional, TypeVar, cast
class _MinMaxDateTimeFieldsDTOFactory(_FunctionArgDTOFactory):
types: ClassVar[set[type[Any]]] = {datetime}
@override
def dto_name(self, base_name: str, dto_config: DTOConfig, node: Optional[Node[Relation[Any, UnmappedStrawberryGraphQLDTO[ModelT]], None]]=None) -> str:
return f'{base_name}MinMaxDateTimeFields'
|
class _MinMaxDateTimeFieldsDTOFactory(_FunctionArgDTOFactory):
@override
def dto_name(self, base_name: str, dto_config: DTOConfig, node: Optional[Node[Relation[Any, UnmappedStrawberryGraphQLDTO[ModelT]], None]]=None) -> str:
pass
| 3
| 0
| 7
| 0
| 7
| 0
| 1
| 0
| 1
| 6
| 4
| 0
| 1
| 0
| 1
| 36
| 11
| 1
| 10
| 9
| 2
| 0
| 4
| 3
| 2
| 1
| 4
| 0
| 1
|
328,026
|
gazorby/strawchemy
|
/Users/umroot/Documents/PhD_works/PhD-Core-Contents/Class-level-dataset-curation/unseen_data/git_repos_for_analysis/gazorby_strawchemy/src/strawchemy/strawberry/factories/aggregations.py
|
strawchemy.strawberry.factories.aggregations._MinMaxFieldsDTOFactory
|
from decimal import Decimal
from datetime import date, datetime, time, timedelta
from strawchemy.strawberry.dto import DTOKey, EnumDTO, FilterFunctionInfo, FunctionArgFieldDefinition, GraphQLFieldDefinition, OutputFunctionInfo, UnmappedStrawberryGraphQLDTO
from typing_extensions import override
from typing import TYPE_CHECKING, Any, ClassVar, Optional, TypeVar, cast
class _MinMaxFieldsDTOFactory(_FunctionArgDTOFactory):
types: ClassVar[set[type[Any]]] = {int, float, str, Decimal, date, datetime, time}
@override
def dto_name(self, base_name: str, dto_config: DTOConfig, node: Optional[Node[Relation[Any, UnmappedStrawberryGraphQLDTO[ModelT]], None]]=None) -> str:
return f'{base_name}MinMaxFields'
|
class _MinMaxFieldsDTOFactory(_FunctionArgDTOFactory):
@override
def dto_name(self, base_name: str, dto_config: DTOConfig, node: Optional[Node[Relation[Any, UnmappedStrawberryGraphQLDTO[ModelT]], None]]=None) -> str:
pass
| 3
| 0
| 7
| 0
| 7
| 0
| 1
| 0
| 1
| 6
| 4
| 0
| 1
| 0
| 1
| 36
| 11
| 1
| 10
| 9
| 2
| 0
| 4
| 3
| 2
| 1
| 4
| 0
| 1
|
328,027
|
gazorby/strawchemy
|
/Users/umroot/Documents/PhD_works/PhD-Core-Contents/Class-level-dataset-curation/unseen_data/git_repos_for_analysis/gazorby_strawchemy/src/strawchemy/strawberry/factories/aggregations.py
|
strawchemy.strawberry.factories.aggregations._MinMaxNumericFieldsDTOFactory
|
from decimal import Decimal
from typing import TYPE_CHECKING, Any, ClassVar, Optional, TypeVar, cast
from strawchemy.strawberry.dto import DTOKey, EnumDTO, FilterFunctionInfo, FunctionArgFieldDefinition, GraphQLFieldDefinition, OutputFunctionInfo, UnmappedStrawberryGraphQLDTO
from typing_extensions import override
class _MinMaxNumericFieldsDTOFactory(_FunctionArgDTOFactory):
types: ClassVar[set[type[Any]]] = {int, float, Decimal}
@override
def dto_name(self, base_name: str, dto_config: DTOConfig, node: Optional[Node[Relation[Any, UnmappedStrawberryGraphQLDTO[ModelT]], None]]=None) -> str:
return f'{base_name}MinMaxNumericFields'
|
class _MinMaxNumericFieldsDTOFactory(_FunctionArgDTOFactory):
@override
def dto_name(self, base_name: str, dto_config: DTOConfig, node: Optional[Node[Relation[Any, UnmappedStrawberryGraphQLDTO[ModelT]], None]]=None) -> str:
pass
| 3
| 0
| 7
| 0
| 7
| 0
| 1
| 0
| 1
| 6
| 4
| 0
| 1
| 0
| 1
| 36
| 11
| 1
| 10
| 9
| 2
| 0
| 4
| 3
| 2
| 1
| 4
| 0
| 1
|
328,028
|
gazorby/strawchemy
|
/Users/umroot/Documents/PhD_works/PhD-Core-Contents/Class-level-dataset-curation/unseen_data/git_repos_for_analysis/gazorby_strawchemy/src/strawchemy/strawberry/factories/aggregations.py
|
strawchemy.strawberry.factories.aggregations._MinMaxStringFieldsDTOFactory
|
from typing_extensions import override
from typing import TYPE_CHECKING, Any, ClassVar, Optional, TypeVar, cast
from strawchemy.strawberry.dto import DTOKey, EnumDTO, FilterFunctionInfo, FunctionArgFieldDefinition, GraphQLFieldDefinition, OutputFunctionInfo, UnmappedStrawberryGraphQLDTO
class _MinMaxStringFieldsDTOFactory(_FunctionArgDTOFactory):
types: ClassVar[set[type[Any]]] = {str}
@override
def dto_name(self, base_name: str, dto_config: DTOConfig, node: Optional[Node[Relation[Any, UnmappedStrawberryGraphQLDTO[ModelT]], None]]=None) -> str:
return f'{base_name}MinMaxStringFields'
|
class _MinMaxStringFieldsDTOFactory(_FunctionArgDTOFactory):
@override
def dto_name(self, base_name: str, dto_config: DTOConfig, node: Optional[Node[Relation[Any, UnmappedStrawberryGraphQLDTO[ModelT]], None]]=None) -> str:
pass
| 3
| 0
| 7
| 0
| 7
| 0
| 1
| 0
| 1
| 6
| 4
| 0
| 1
| 0
| 1
| 36
| 11
| 1
| 10
| 9
| 2
| 0
| 4
| 3
| 2
| 1
| 4
| 0
| 1
|
328,029
|
gazorby/strawchemy
|
/Users/umroot/Documents/PhD_works/PhD-Core-Contents/Class-level-dataset-curation/unseen_data/git_repos_for_analysis/gazorby_strawchemy/src/strawchemy/strawberry/factories/aggregations.py
|
strawchemy.strawberry.factories.aggregations._MinMaxTimeFieldsDTOFactory
|
from strawchemy.strawberry.dto import DTOKey, EnumDTO, FilterFunctionInfo, FunctionArgFieldDefinition, GraphQLFieldDefinition, OutputFunctionInfo, UnmappedStrawberryGraphQLDTO
from typing_extensions import override
from typing import TYPE_CHECKING, Any, ClassVar, Optional, TypeVar, cast
from datetime import date, datetime, time, timedelta
class _MinMaxTimeFieldsDTOFactory(_FunctionArgDTOFactory):
types: ClassVar[set[type[Any]]] = {time}
@override
def dto_name(self, base_name: str, dto_config: DTOConfig, node: Optional[Node[Relation[Any, UnmappedStrawberryGraphQLDTO[ModelT]], None]]=None) -> str:
return f'{base_name}MinMaxTimeFields'
|
class _MinMaxTimeFieldsDTOFactory(_FunctionArgDTOFactory):
@override
def dto_name(self, base_name: str, dto_config: DTOConfig, node: Optional[Node[Relation[Any, UnmappedStrawberryGraphQLDTO[ModelT]], None]]=None) -> str:
pass
| 3
| 0
| 7
| 0
| 7
| 0
| 1
| 0
| 1
| 6
| 4
| 0
| 1
| 0
| 1
| 36
| 11
| 1
| 10
| 9
| 2
| 0
| 4
| 3
| 2
| 1
| 4
| 0
| 1
|
328,030
|
gazorby/strawchemy
|
/Users/umroot/Documents/PhD_works/PhD-Core-Contents/Class-level-dataset-curation/unseen_data/git_repos_for_analysis/gazorby_strawchemy/src/strawchemy/strawberry/factories/aggregations.py
|
strawchemy.strawberry.factories.aggregations._NumericFieldsDTOFactory
|
from strawchemy.strawberry.dto import DTOKey, EnumDTO, FilterFunctionInfo, FunctionArgFieldDefinition, GraphQLFieldDefinition, OutputFunctionInfo, UnmappedStrawberryGraphQLDTO
from typing_extensions import override
from decimal import Decimal
from typing import TYPE_CHECKING, Any, ClassVar, Optional, TypeVar, cast
class _NumericFieldsDTOFactory(_FunctionArgDTOFactory):
types: ClassVar[set[type[Any]]] = {int, float, Decimal}
@override
def dto_name(self, base_name: str, dto_config: DTOConfig, node: Optional[Node[Relation[Any, UnmappedStrawberryGraphQLDTO[ModelT]], None]]=None) -> str:
return f'{base_name}NumericFields'
|
class _NumericFieldsDTOFactory(_FunctionArgDTOFactory):
@override
def dto_name(self, base_name: str, dto_config: DTOConfig, node: Optional[Node[Relation[Any, UnmappedStrawberryGraphQLDTO[ModelT]], None]]=None) -> str:
pass
| 3
| 0
| 7
| 0
| 7
| 0
| 1
| 0
| 1
| 6
| 4
| 0
| 1
| 0
| 1
| 36
| 11
| 1
| 10
| 9
| 2
| 0
| 4
| 3
| 2
| 1
| 4
| 0
| 1
|
328,031
|
gazorby/strawchemy
|
/Users/umroot/Documents/PhD_works/PhD-Core-Contents/Class-level-dataset-curation/unseen_data/git_repos_for_analysis/gazorby_strawchemy/src/strawchemy/strawberry/factories/aggregations.py
|
strawchemy.strawberry.factories.aggregations._SumFieldsDTOFactory
|
from decimal import Decimal
from typing_extensions import override
from datetime import date, datetime, time, timedelta
from strawchemy.strawberry.dto import DTOKey, EnumDTO, FilterFunctionInfo, FunctionArgFieldDefinition, GraphQLFieldDefinition, OutputFunctionInfo, UnmappedStrawberryGraphQLDTO
from typing import TYPE_CHECKING, Any, ClassVar, Optional, TypeVar, cast
class _SumFieldsDTOFactory(_FunctionArgDTOFactory):
types: ClassVar[set[type[Any]]] = {int, float, str, Decimal, timedelta}
@override
def dto_name(self, base_name: str, dto_config: DTOConfig, node: Optional[Node[Relation[Any, UnmappedStrawberryGraphQLDTO[ModelT]], None]]=None) -> str:
return f'{base_name}SumFields'
|
class _SumFieldsDTOFactory(_FunctionArgDTOFactory):
@override
def dto_name(self, base_name: str, dto_config: DTOConfig, node: Optional[Node[Relation[Any, UnmappedStrawberryGraphQLDTO[ModelT]], None]]=None) -> str:
pass
| 3
| 0
| 7
| 0
| 7
| 0
| 1
| 0
| 1
| 6
| 4
| 0
| 1
| 0
| 1
| 36
| 11
| 1
| 10
| 9
| 2
| 0
| 4
| 3
| 2
| 1
| 4
| 0
| 1
|
328,032
|
gazorby/strawchemy
|
/Users/umroot/Documents/PhD_works/PhD-Core-Contents/Class-level-dataset-curation/unseen_data/git_repos_for_analysis/gazorby_strawchemy/src/strawchemy/strawberry/factories/base.py
|
strawchemy.strawberry.factories.base.GraphQLDTOFactory
|
from strawchemy.utils import get_annotations
from strawchemy.graph import Node
from strawchemy.exceptions import StrawchemyError
from strawchemy.strawberry._instance import MapperModelInstance
from strawchemy.strawberry.dto import BooleanFilterDTO, DTOKey, GraphQLFieldDefinition, MappedStrawberryGraphQLDTO, OrderByDTO, StrawchemyDTOAttributes, UnmappedStrawberryGraphQLDTO
from strawberry.types.auto import StrawberryAuto
from strawchemy.strawberry.typing import GraphQLDTOT, GraphQLPurpose, MappedGraphQLDTO
from sqlalchemy.orm import DeclarativeBase, QueryableAttribute
from strawchemy.strawberry import typing as strawchemy_typing
from typing_extensions import TypeAlias, dataclass_transform, override
from strawchemy.dto.base import DTOBackend, DTOBase, DTOFactory, DTOFieldDefinition, Relation
from typing import TYPE_CHECKING, Any, Literal, Optional, TypeVar, Union, get_type_hints
from functools import cached_property
from strawchemy.dto.types import DTOAuto, DTOConfig, DTOScope, Purpose
from strawchemy.strawberry._registry import RegistryTypeInfo
from strawchemy.dto.utils import config
from collections.abc import Generator, Sequence
import dataclasses
from strawchemy.types import DefaultOffsetPagination
from strawberry.utils.typing import type_has_annotation
class GraphQLDTOFactory(DTOFactory[DeclarativeBase, QueryableAttribute[Any], GraphQLDTOT]):
inspector: SQLAlchemyGraphQLInspector
def __init__(self, mapper: Strawchemy, backend: DTOBackend[GraphQLDTOT], handle_cycles: bool=True, type_map: Optional[dict[Any, Any]]=None, **kwargs: Any) -> None:
super().__init__(mapper.config.inspector, backend, handle_cycles, type_map, **kwargs)
self._mapper = mapper
def _type_info(self, dto: type[StrawchemyDTOT], dto_config: DTOConfig, current_node: Optional[Node[Relation[Any, GraphQLDTOT], None]], override: bool=False, user_defined: bool=False, child_options: Optional[_ChildOptions]=None) -> RegistryTypeInfo:
child_options = child_options or _ChildOptions()
graphql_type = self.graphql_type(dto_config)
model: type[DeclarativeBase] | None = dto.__dto_model__ if issubclass(dto, MappedStrawberryGraphQLDTO) else None
default_name = self.root_dto_name(model, dto_config, current_node) if model else dto.__name__
type_info = RegistryTypeInfo(name=dto.__name__, default_name=default_name, graphql_type=graphql_type, override=override, user_defined=user_defined, pagination=DefaultOffsetPagination() if child_options.pagination is True else child_options.pagination, order_by=child_options.order_by, scope=dto_config.scope, model=model, exclude_from_scope=dto_config.exclude_from_scope)
if self._mapper.registry.name_clash(type_info) and current_node is not None:
type_info = dataclasses.replace(type_info, name=''.join((node.value.name for node in current_node.path_from_root())))
return type_info
def _register_type(self, dto: type[StrawchemyDTOT], dto_config: DTOConfig, current_node: Optional[Node[Relation[Any, GraphQLDTOT], None]], description: Optional[str]=None, directives: Optional[Sequence[object]]=(), override: bool=False, user_defined: bool=False, child_options: Optional[_ChildOptions]=None) -> type[StrawchemyDTOT]:
type_info = self._type_info(dto, dto_config, override=override, user_defined=user_defined, child_options=child_options, current_node=current_node)
self._raise_if_type_conflicts(type_info)
return self._mapper.registry.register_type(dto, type_info, description=description or dto.__strawchemy_description__, directives=directives)
def _check_model_instance_attribute(self, base: type[Any]) -> None:
instance_attributes = [name for name, annotation in get_annotations(base).items() if type_has_annotation(annotation, MapperModelInstance)]
if len(instance_attributes) > 1:
msg = f'{base.__name__} has multiple `MapperModelInstance` attributes: {instance_attributes}'
raise StrawchemyError(msg)
def _resolve_config(self, dto_config: DTOConfig, base: type[Any]) -> DTOConfig:
config = dto_config.with_base_annotations(base)
try:
base_annotations = get_type_hints(base, include_extras=True)
except NameError:
base_annotations = get_annotations(base)
base_annotations_copy = base_annotations.copy()
for name, annotation in base_annotations.items():
if type_has_annotation(annotation, StrawberryAuto):
config.annotation_overrides[name] = DTOAuto
base_annotations_copy.pop(name)
base.__annotations__ = base_annotations_copy
return config
def _raise_if_type_conflicts(self, type_info: RegistryTypeInfo) -> None:
if self._mapper.registry.non_override_exists(type_info):
msg = f"Type `{type_info.name}` cannot be auto generated because it's already declared. You may want to set `override=True` on the existing type to use it everywhere."
raise StrawchemyError(msg)
def _config(self, purpose: Purpose, include: Optional[IncludeFields]=None, exclude: Optional[ExcludeFields]=None, partial: Optional[bool]=None, type_map: Optional[Mapping[Any, Any]]=None, aliases: Optional[Mapping[str, str]]=None, alias_generator: Optional[Callable[[str], str]]=None, scope: Optional[DTOScope]=None, tags: Optional[set[str]]=None) -> DTOConfig:
return config(purpose, include=include, exclude=exclude, partial=partial, type_map=type_map, alias_generator=alias_generator, aliases=aliases, scope=scope, tags=tags)
def _type_wrapper(self, model: type[T], *, mode: GraphQLPurpose, include: Optional[IncludeFields]=None, exclude: Optional[ExcludeFields]=None, partial: Optional[bool]=None, type_map: Optional[Mapping[Any, Any]]=None, aliases: Optional[Mapping[str, str]]=None, alias_generator: Optional[Callable[[str], str]]=None, child_pagination: Union[bool, DefaultOffsetPagination]=False, child_order_by: bool=False, filter_input: Optional[type[BooleanFilterDTO]]=None, order_by: Optional[type[OrderByDTO]]=None, name: Optional[str]=None, description: Optional[str]=None, directives: Optional[Sequence[object]]=(), query_hook: Optional[Union[QueryHook[T], list[QueryHook[T]]]]=None, override: bool=False, purpose: Purpose=Purpose.READ, scope: DTOScope | None=None) -> Callable[[type[Any]], type[GraphQLDTOT]]:
def wrapper(class_: type[Any]) -> type[GraphQLDTOT]:
dto_config = config(purpose, include=include, exclude=exclude, partial=partial, type_map=type_map, alias_generator=alias_generator, aliases=aliases, scope=scope, tags={mode})
dto = self.factory(model=model, dto_config=dto_config, base=class_, name=name, description=description, directives=directives, query_hook=query_hook, override=override, user_defined=True, mode=mode, child_options=_ChildOptions(pagination=child_pagination, order_by=child_order_by))
dto.__strawchemy_query_hook__ = query_hook
if issubclass(dto, MappedStrawberryGraphQLDTO):
dto.__strawchemy_filter__ = filter_input
dto.__strawchemy_order_by__ = order_by
dto.__strawchemy_purpose__ = mode
return dto
return wrapper
def _input_wrapper(self, model: type[T], *, mode: GraphQLPurpose, include: Optional[IncludeFields]=None, exclude: Optional[ExcludeFields]=None, partial: Optional[bool]=None, type_map: Optional[Mapping[Any, Any]]=None, aliases: Optional[Mapping[str, str]]=None, alias_generator: Optional[Callable[[str], str]]=None, name: Optional[str]=None, description: Optional[str]=None, directives: Optional[Sequence[object]]=(), override: bool=False, purpose: Purpose=Purpose.WRITE, scope: DTOScope | None=None, **kwargs: Any) -> Callable[[type[Any]], type[GraphQLDTOT]]:
def wrapper(class_: type[Any]) -> type[GraphQLDTOT]:
dto_config = self._config(purpose, include=include, exclude=exclude, partial=partial, type_map=type_map, alias_generator=alias_generator, aliases=aliases, scope=scope, tags={mode})
dto = self.factory(model=model, dto_config=dto_config, base=class_, name=name, description=description, directives=directives, override=override, user_defined=True, mode=mode, **kwargs)
dto.__strawchemy_purpose__ = mode
return dto
return wrapper
@cached_property
def _namespace(self) -> dict[str, Any]:
from strawchemy.sqlalchemy import hook
return vars(strawchemy_typing) | vars(hook)
@classmethod
def graphql_type(cls, dto_config: DTOConfig) -> GraphQLType:
return 'input' if dto_config.purpose is Purpose.WRITE else 'object'
def type_description(self) -> str:
return 'GraphQL type'
@override
def type_hint_namespace(self) -> dict[str, Any]:
return super().type_hint_namespace() | self._namespace
@override
def iter_field_definitions(self, name: str, model: type[T], dto_config: DTOConfig, base: Optional[type[DTOBase[DeclarativeBase]]], node: Node[Relation[DeclarativeBase, GraphQLDTOT], None], raise_if_no_fields: bool=False, *, field_map: Optional[dict[DTOKey, GraphQLFieldDefinition]]=None, **kwargs: Any) -> Generator[DTOFieldDefinition[DeclarativeBase, QueryableAttribute[Any]], None, None]:
field_map = field_map if field_map is not None else {}
for field in super().iter_field_definitions(name, model, dto_config, base, node, raise_if_no_fields, **kwargs):
key = DTOKey.from_dto_node(node)
graphql_field = GraphQLFieldDefinition.from_field(field)
yield graphql_field
field_map[key + field.name] = graphql_field
@override
def factory(self, model: type[T], dto_config: DTOConfig, base: Optional[type[Any]]=None, name: Optional[str]=None, parent_field_def: Optional[DTOFieldDefinition[DeclarativeBase, QueryableAttribute[Any]]]=None, current_node: Optional[Node[Relation[Any, GraphQLDTOT], None]]=None, raise_if_no_fields: bool=False, tags: Optional[set[str]]=None, backend_kwargs: Optional[dict[str, Any]]=None, *, description: Optional[str]=None, directives: Optional[Sequence[object]]=(), override: bool=False, register_type: bool=True, user_defined: bool=False, **kwargs: Any) -> type[GraphQLDTOT]:
field_map: dict[DTOKey, GraphQLFieldDefinition] = {}
if base:
self._check_model_instance_attribute(base)
dto_config = self._resolve_config(dto_config, base)
dto = super().factory(model, dto_config, base, name, parent_field_def, current_node, raise_if_no_fields, tags, backend_kwargs=backend_kwargs, field_map=field_map, **kwargs)
if not dto.__strawchemy_field_map__:
dto.__strawchemy_field_map__ = field_map
dto.__strawchemy_description__ = self.type_description()
if register_type:
return self._register_type(dto, dto_config, current_node=current_node, description=description, directives=directives, override=override, user_defined=user_defined)
return dto
|
class GraphQLDTOFactory(DTOFactory[DeclarativeBase, QueryableAttribute[Any], GraphQLDTOT]):
def __init__(self, mapper: Strawchemy, backend: DTOBackend[GraphQLDTOT], handle_cycles: bool=True, type_map: Optional[dict[Any, Any]]=None, **kwargs: Any) -> None:
pass
def _type_info(self, dto: type[StrawchemyDTOT], dto_config: DTOConfig, current_node: Optional[Node[Relation[Any, GraphQLDTOT], None]], override: bool=False, user_defined: bool=False, child_options: Optional[_ChildOptions]=None) -> RegistryTypeInfo:
pass
def _register_type(self, dto: type[StrawchemyDTOT], dto_config: DTOConfig, current_node: Optional[Node[Relation[Any, GraphQLDTOT], None]], description: Optional[str]=None, directives: Optional[Sequence[object]]=(), override:
pass
def _check_model_instance_attribute(self, base: type[Any]) -> None:
pass
def _resolve_config(self, dto_config: DTOConfig, base: type[Any]) -> DTOConfig:
pass
def _raise_if_type_conflicts(self, type_info: RegistryTypeInfo) -> None:
pass
def _config(self, purpose: Purpose, include: Optional[IncludeFields]=None, exclude: Optional[ExcludeFields]=None, partial: Optional[bool]=None, type_map: Optional[Mapping[Any, Any]]=None, aliases: Optional[Mapping[str, str]]=None, alias_generator: Optional[Callable[[str], str]]=None, scope: Optional[DTOScope]=None, tags: Optional[set[str]]=None) -> DTOConfig:
pass
def _type_wrapper(self, model: type[T], *, mode: GraphQLPurpose, include: Optional[IncludeFields]=None, exclude: Optional[ExcludeFields]=None, partial: Optional[bool]=None, type_map: Optional[Mapping[Any, Any]]=None, aliases: Optional[Mapping[str, str]]=None, alias_generator: Optional[Callable[[str], str]]=None, child_pagination: Union[bool, DefaultOffsetPagination]=False, child_order_by: bool=False, filter_input: Optional[type[BooleanFilterDTO]]=None, order_by: Optional[type[OrderByDTO]]=None, name: Optional[str]=None, description: Optional[str]=None, directives: Optional[Sequence[object]]=(), query_hook:
pass
def wrapper(class_: type[Any]) -> type[GraphQLDTOT]:
pass
def _input_wrapper(self, model: type[T], *, mode: GraphQLPurpose, include: Optional[IncludeFields]=None, exclude: Optional[ExcludeFields]=None, partial: Optional[bool]=None, type_map: Optional[Mapping[Any, Any]]=None, aliases: Optional[Mapping[str, str]]=None, alias_generator: Optional[Callable[[str], str]]=None, name: Optional[str]=None, description: Optional[str]=None, directives: Optional[Sequence[object]]=(), override:
pass
def wrapper(class_: type[Any]) -> type[GraphQLDTOT]:
pass
@cached_property
def _namespace(self) -> dict[str, Any]:
pass
@classmethod
def graphql_type(cls, dto_config: DTOConfig) -> GraphQLType:
pass
def type_description(self) -> str:
pass
@override
def type_hint_namespace(self) -> dict[str, Any]:
pass
@override
def iter_field_definitions(self, name: str, model: type[T], dto_config: DTOConfig, base: Optional[type[DTOBase[DeclarativeBase]]], node: Node[Relation[DeclarativeBase, GraphQLDTOT], None], raise_if_no_fields: bool=False, *, field_map: Optional[dict[DTOKey, GraphQLFieldDefinition]]=None, **kwargs: Any) -> Generator[DTOFieldDefinition[DeclarativeBase, QueryableAttribute[Any]], None, None]:
pass
@override
def factory(self, model: type[T], dto_config: DTOConfig, base: Optional[type[Any]]=None, name: Optional[str]=None, parent_field_def: Optional[DTOFieldDefinition[DeclarativeBase, QueryableAttribute[Any]]]=None, current_node: Optional[Node[Relation[Any, GraphQLDTOT], None]]=None, raise_if_no_fields: bool=False, tags: Optional[set[str]]=None, backend_kwargs: Optional[dict[str, Any]]=None, *, description: Optional[str]=None, directives: Optional[Sequence[object]]=(), override:
pass
| 23
| 0
| 19
| 0
| 19
| 0
| 2
| 0
| 1
| 31
| 18
| 4
| 14
| 1
| 15
| 30
| 296
| 18
| 278
| 143
| 156
| 0
| 85
| 39
| 66
| 4
| 2
| 2
| 31
|
328,033
|
gazorby/strawchemy
|
/Users/umroot/Documents/PhD_works/PhD-Core-Contents/Class-level-dataset-curation/unseen_data/git_repos_for_analysis/gazorby_strawchemy/src/strawchemy/strawberry/factories/base.py
|
strawchemy.strawberry.factories.base.StrawchemyMappedFactory
|
from typing_extensions import TypeAlias, dataclass_transform, override
from strawchemy.types import DefaultOffsetPagination
from strawchemy.strawberry.dto import BooleanFilterDTO, DTOKey, GraphQLFieldDefinition, MappedStrawberryGraphQLDTO, OrderByDTO, StrawchemyDTOAttributes, UnmappedStrawberryGraphQLDTO
from collections.abc import Generator, Sequence
from strawchemy.strawberry.typing import GraphQLDTOT, GraphQLPurpose, MappedGraphQLDTO
from strawberry import UNSET
from strawchemy.dto.base import DTOBackend, DTOBase, DTOFactory, DTOFieldDefinition, Relation
from strawchemy.dto.types import DTOAuto, DTOConfig, DTOScope, Purpose
from strawchemy.graph import Node
from sqlalchemy.orm import DeclarativeBase, QueryableAttribute
from typing import TYPE_CHECKING, Any, Literal, Optional, TypeVar, Union, get_type_hints
from strawchemy.exceptions import StrawchemyError
class StrawchemyMappedFactory(GraphQLDTOFactory[MappedGraphQLDTOT]):
def _root_input_config(self, model: type[Any], dto_config: DTOConfig, mode: GraphQLPurpose) -> DTOConfig:
annotations_overrides: dict[str, Any] = {}
partial = dto_config.partial
exclude_defaults = dto_config.exclude_defaults
id_fields = self.inspector.id_field_definitions(model, dto_config)
if mode == 'update_by_pk_input':
if set(dto_config.exclude) & {name for name, _ in id_fields}:
msg = 'You cannot exclude primary key columns from an input type intended for create or update mutations'
raise StrawchemyError(msg)
annotations_overrides |= {name: field.type_hint for name, field in id_fields}
if mode == 'update_by_filter_input':
exclude_defaults = True
if mode in {'update_by_pk_input', 'update_by_filter_input'}:
partial = True
elif dto_config.include == 'all':
for name, field in id_fields:
if self.inspector.has_default(field.model_field):
annotations_overrides[name] = Optional[field.type_hint]
return dto_config.copy_with(annotation_overrides=annotations_overrides, partial=partial, partial_default=UNSET, unset_sentinel=UNSET, exclude_defaults=exclude_defaults)
@dataclass_transform(order_default=True, kw_only_default=True)
def type(self, model: type[T], *, include: Optional[IncludeFields]=None, exclude: Optional[ExcludeFields]=None, partial: Optional[bool]=None, type_map: Optional[Mapping[Any, Any]]=None, aliases: Optional[Mapping[str, str]]=None, alias_generator: Optional[Callable[[str], str]]=None, child_pagination: Union[bool, DefaultOffsetPagination]=False, child_order_by: bool=False, filter_input: Optional[type[BooleanFilterDTO]]=None, order_by: Optional[type[OrderByDTO]]=None, name: Optional[str]=None, description: Optional[str]=None, directives: Optional[Sequence[object]]=(), query_hook: Optional[Union[QueryHook[T], list[QueryHook[T]]]]=None, override: bool=False, purpose: Purpose=Purpose.READ, scope: TypeScope | None=None, mode: GraphQLPurpose='type') -> Callable[[type[Any]], type[MappedGraphQLDTO[T]]]:
return self._type_wrapper(model=model, include=include, exclude=exclude, partial=partial, type_map=type_map, aliases=aliases, alias_generator=alias_generator, child_pagination=child_pagination, child_order_by=child_order_by, filter_input=filter_input, order_by=order_by, name=name, description=description, directives=directives, query_hook=query_hook, override=override, purpose=purpose, scope=type_scope_to_dto_scope(scope) if scope else None, mode=mode)
@dataclass_transform(order_default=True, kw_only_default=True)
def input(self, model: type[T], *, mode: GraphQLPurpose, include: Optional[IncludeFields]=None, exclude: Optional[ExcludeFields]=None, partial: Optional[bool]=None, type_map: Optional[Mapping[Any, Any]]=None, aliases: Optional[Mapping[str, str]]=None, alias_generator: Optional[Callable[[str], str]]=None, name: Optional[str]=None, description: Optional[str]=None, directives: Optional[Sequence[object]]=(), override: bool=False, purpose: Purpose=Purpose.WRITE, scope: TypeScope | None=None, **kwargs: Any) -> Callable[[type[Any]], type[MappedGraphQLDTO[T]]]:
return self._input_wrapper(model=model, include=include, exclude=exclude, partial=partial, type_map=type_map, aliases=aliases, alias_generator=alias_generator, name=name, description=description, directives=directives, override=override, purpose=purpose, mode=mode, scope=type_scope_to_dto_scope(scope) if scope else None, **kwargs)
@override
def factory(self, model: type[T], dto_config: DTOConfig, base: Optional[type[Any]]=None, name: Optional[str]=None, parent_field_def: Optional[DTOFieldDefinition[DeclarativeBase, QueryableAttribute[Any]]]=None, current_node: Optional[Node[Relation[Any, MappedGraphQLDTOT], None]]=None, raise_if_no_fields: bool=False, tags: Optional[set[str]]=None, backend_kwargs: Optional[dict[str, Any]]=None, *, mode: Optional[GraphQLPurpose]=None, **kwargs: Any) -> type[MappedGraphQLDTOT]:
if mode and dto_config.purpose is Purpose.WRITE:
dto_config = self._root_input_config(model, dto_config, mode)
return super().factory(model, dto_config, base, name, parent_field_def, current_node, raise_if_no_fields, tags, backend_kwargs=backend_kwargs, mode=mode, **kwargs)
|
class StrawchemyMappedFactory(GraphQLDTOFactory[MappedGraphQLDTOT]):
def _root_input_config(self, model: type[Any], dto_config: DTOConfig, mode: GraphQLPurpose) -> DTOConfig:
pass
@dataclass_transform(order_default=True, kw_only_default=True)
def type(self, model: type[T], *, include: Optional[IncludeFields]=None, exclude: Optional[ExcludeFields]=None, partial: Optional[bool]=None, type_map: Optional[Mapping[Any, Any]]=None, aliases: Optional[Mapping[str, str]]=None, alias_generator: Optional[Callable[[str], str]]=None, child_pagination: Union[bool, DefaultOffsetPagination]=False, child_order_by: bool=False, filter_input: Optional[type[BooleanFilterDTO]]=None, order_by: Optional[type[OrderByDTO]]=None, name: Optional[str]=None, description: Optional[str]=None, directives: Optional[Sequence[object]]=(), query_hook:
pass
@dataclass_transform(order_default=True, kw_only_default=True)
def input(self, model: type[T], *, mode: GraphQLPurpose, include: Optional[IncludeFields]=None, exclude: Optional[ExcludeFields]=None, partial: Optional[bool]=None, type_map: Optional[Mapping[Any, Any]]=None, aliases: Optional[Mapping[str, str]]=None, alias_generator: Optional[Callable[[str], str]]=None, name: Optional[str]=None, description: Optional[str]=None, directives: Optional[Sequence[object]]=(), override:
pass
@override
def factory(self, model: type[T], dto_config: DTOConfig, base: Optional[type[Any]]=None, name: Optional[str]=None, parent_field_def: Optional[DTOFieldDefinition[DeclarativeBase, QueryableAttribute[Any]]]=None, current_node: Optional[Node[Relation[Any, MappedGraphQLDTOT], None]]=None, raise_if_no_fields: bool=False, tags: Optional[set[str]]=None, backend_kwargs: Optional[dict[str, Any]]=None, *, mode: Optional[GraphQLPurpose]=None, **kwargs: Any) -> type[MappedGraphQLDTOT]:
pass
| 8
| 0
| 33
| 0
| 32
| 1
| 3
| 0.02
| 1
| 22
| 10
| 1
| 4
| 0
| 4
| 34
| 137
| 3
| 132
| 63
| 75
| 2
| 27
| 10
| 22
| 8
| 3
| 3
| 12
|
328,034
|
gazorby/strawchemy
|
/Users/umroot/Documents/PhD_works/PhD-Core-Contents/Class-level-dataset-curation/unseen_data/git_repos_for_analysis/gazorby_strawchemy/src/strawchemy/strawberry/factories/base.py
|
strawchemy.strawberry.factories.base.StrawchemyUnMappedDTOFactory
|
from typing_extensions import TypeAlias, dataclass_transform, override
from strawchemy.dto.types import DTOAuto, DTOConfig, DTOScope, Purpose
from strawchemy.types import DefaultOffsetPagination
from collections.abc import Generator, Sequence
from strawchemy.strawberry.dto import BooleanFilterDTO, DTOKey, GraphQLFieldDefinition, MappedStrawberryGraphQLDTO, OrderByDTO, StrawchemyDTOAttributes, UnmappedStrawberryGraphQLDTO
from typing import TYPE_CHECKING, Any, Literal, Optional, TypeVar, Union, get_type_hints
from strawchemy.strawberry.typing import GraphQLDTOT, GraphQLPurpose, MappedGraphQLDTO
class StrawchemyUnMappedDTOFactory(GraphQLDTOFactory[UnmappedGraphQLDTOT]):
@dataclass_transform(order_default=True, kw_only_default=True)
def input(self, model: type[T], *, include: Optional[IncludeFields]=None, exclude: Optional[ExcludeFields]=None, partial: Optional[bool]=None, type_map: Optional[Mapping[Any, Any]]=None, aliases: Optional[Mapping[str, str]]=None, alias_generator: Optional[Callable[[str], str]]=None, name: Optional[str]=None, description: Optional[str]=None, directives: Optional[Sequence[object]]=(), override: bool=False, purpose: Purpose=Purpose.WRITE, **kwargs: Any) -> Callable[[type[Any]], type[UnmappedStrawberryGraphQLDTO[T]]]:
return self._input_wrapper(model=model, include=include, exclude=exclude, partial=partial, type_map=type_map, aliases=aliases, alias_generator=alias_generator, name=name, description=description, directives=directives, override=override, purpose=purpose, **kwargs)
@dataclass_transform(order_default=True, kw_only_default=True)
def type(self, model: type[T], include: Optional[IncludeFields]=None, exclude: Optional[ExcludeFields]=None, partial: Optional[bool]=None, type_map: Optional[Mapping[Any, Any]]=None, aliases: Optional[Mapping[str, str]]=None, alias_generator: Optional[Callable[[str], str]]=None, child_pagination: Union[bool, DefaultOffsetPagination]=False, child_order_by: bool=False, filter_input: Optional[type[BooleanFilterDTO]]=None, order_by: Optional[type[OrderByDTO]]=None, name: Optional[str]=None, description: Optional[str]=None, directives: Optional[Sequence[object]]=(), query_hook: Optional[Union[QueryHook[T], list[QueryHook[T]]]]=None, override: bool=False, purpose: Purpose=Purpose.READ, mode: GraphQLPurpose='type') -> Callable[[type[Any]], type[UnmappedStrawberryGraphQLDTO[T]]]:
return self._type_wrapper(model=model, include=include, exclude=exclude, partial=partial, type_map=type_map, aliases=aliases, alias_generator=alias_generator, child_pagination=child_pagination, child_order_by=child_order_by, filter_input=filter_input, order_by=order_by, name=name, description=description, directives=directives, query_hook=query_hook, override=override, purpose=purpose, mode=mode)
|
class StrawchemyUnMappedDTOFactory(GraphQLDTOFactory[UnmappedGraphQLDTOT]):
@dataclass_transform(order_default=True, kw_only_default=True)
def input(self, model: type[T], *, include: Optional[IncludeFields]=None, exclude: Optional[ExcludeFields]=None, partial: Optional[bool]=None, type_map: Optional[Mapping[Any, Any]]=None, aliases: Optional[Mapping[str, str]]=None, alias_generator: Optional[Callable[[str], str]]=None, name: Optional[str]=None, description: Optional[str]=None, directives: Optional[Sequence[object]]=(), override:
pass
@dataclass_transform(order_default=True, kw_only_default=True)
def type(self, model: type[T], include: Optional[IncludeFields]=None, exclude: Optional[ExcludeFields]=None, partial: Optional[bool]=None, type_map: Optional[Mapping[Any, Any]]=None, aliases: Optional[Mapping[str, str]]=None, alias_generator: Optional[Callable[[str], str]]=None, child_pagination: Union[bool, DefaultOffsetPagination]=False, child_order_by: bool=False, filter_input: Optional[type[BooleanFilterDTO]]=None, order_by: Optional[type[OrderByDTO]]=None, name: Optional[str]=None, description: Optional[str]=None, directives: Optional[Sequence[object]]=(), query_hook:
pass
| 5
| 0
| 36
| 0
| 36
| 0
| 1
| 0
| 1
| 15
| 6
| 1
| 2
| 0
| 2
| 32
| 75
| 1
| 74
| 40
| 34
| 0
| 5
| 3
| 2
| 1
| 3
| 0
| 2
|
328,035
|
gazorby/strawchemy
|
/Users/umroot/Documents/PhD_works/PhD-Core-Contents/Class-level-dataset-curation/unseen_data/git_repos_for_analysis/gazorby_strawchemy/src/strawchemy/strawberry/factories/base.py
|
strawchemy.strawberry.factories.base._ChildOptions
|
from typing import TYPE_CHECKING, Any, Literal, Optional, TypeVar, Union, get_type_hints
import dataclasses
from strawchemy.types import DefaultOffsetPagination
@dataclasses.dataclass(eq=True, frozen=True)
class _ChildOptions:
pagination: Union[DefaultOffsetPagination, bool] = False
order_by: bool = False
|
@dataclasses.dataclass(eq=True, frozen=True)
class _ChildOptions:
pass
| 2
| 0
| 0
| 0
| 0
| 0
| 0
| 0
| 0
| 0
| 0
| 0
| 0
| 0
| 0
| 0
| 3
| 0
| 3
| 3
| 2
| 0
| 3
| 3
| 2
| 0
| 0
| 0
| 0
|
328,036
|
gazorby/strawchemy
|
/Users/umroot/Documents/PhD_works/PhD-Core-Contents/Class-level-dataset-curation/unseen_data/git_repos_for_analysis/gazorby_strawchemy/src/strawchemy/strawberry/factories/enum.py
|
strawchemy.strawberry.factories.enum.EnumDTOBackend
|
from types import new_class
from typing_extensions import override
from collections.abc import Iterable
from strawchemy.strawberry.dto import EnumDTO, GraphQLFieldDefinition
from inspect import getmodule
from sqlalchemy.orm import DeclarativeBase, QueryableAttribute
from strawchemy.utils import snake_to_lower_camel_case
from typing import TYPE_CHECKING, Any, Optional, TypeVar, cast
from strawchemy.dto.base import DTOBackend, DTOBase, DTOFactory, DTOFieldDefinition, Relation
class EnumDTOBackend(DTOBackend[EnumDTO]):
def __init__(self, to_camel: bool=True) -> None:
self.dto_base = EnumDTO
self.to_camel = to_camel
@override
def build(self, name: str, model: type[DeclarativeBase], field_definitions: Iterable[DTOFieldDefinition[DeclarativeBase, QueryableAttribute[Any]]], base: Optional[type[Any]]=None, values: Optional[Iterable[Any]]=None, **kwargs: Any) -> type[EnumDTO]:
field_map = {snake_to_lower_camel_case(field.name) if self.to_camel else field.name: field for field in field_definitions}
values = list(values or []) or field_map.keys()
def exec_body(namespace: dict[str, Any]) -> Any:
def to_field_definition(self: EnumDTO) -> DTOFieldDefinition[DeclarativeBase, QueryableAttribute[Any]]:
return self.__field_definitions__[self.value]
namespace['field_definition'] = property(to_field_definition)
namespace['__field_definitions__'] = field_map
base = new_class(name=f'{name}Base', bases=(DTOBase,), exec_body=exec_body)
module = __name__
if (model_module := getmodule(model)):
module = model_module.__name__
return cast('type[EnumDTO]', EnumDTO(value=name, names=list(zip(list(field_map), values)), type=base, module=module))
@override
@classmethod
def copy(cls, dto: type[EnumDTO], name: str) -> EnumDTO:
enum = EnumDTO(value=name, names=[(value.name, value.value) for value in dto])
enum.__field_definitions__ = dto.__field_definitions__
return enum
|
class EnumDTOBackend(DTOBackend[EnumDTO]):
def __init__(self, to_camel: bool=True) -> None:
pass
@override
def build(self, name: str, model: type[DeclarativeBase], field_definitions: Iterable[DTOFieldDefinition[DeclarativeBase, QueryableAttribute[Any]]], base: Optional[type[Any]]=None, values: Optional[Iterable[Any]]=None, **kwargs: Any) -> type[EnumDTO]:
pass
def exec_body(namespace: dict[str, Any]) -> Any:
pass
def to_field_definition(self: EnumDTO) -> DTOFieldDefinition[DeclarativeBase, QueryableAttribute[Any]]:
pass
@override
@classmethod
def copy(cls, dto: type[EnumDTO], name: str) -> EnumDTO:
pass
| 9
| 0
| 9
| 1
| 8
| 0
| 1
| 0.03
| 1
| 11
| 3
| 1
| 2
| 2
| 3
| 30
| 42
| 5
| 37
| 22
| 20
| 1
| 21
| 11
| 15
| 3
| 6
| 1
| 7
|
328,037
|
gazorby/strawchemy
|
/Users/umroot/Documents/PhD_works/PhD-Core-Contents/Class-level-dataset-curation/unseen_data/git_repos_for_analysis/gazorby_strawchemy/src/strawchemy/strawberry/factories/enum.py
|
strawchemy.strawberry.factories.enum.EnumDTOFactory
|
from strawchemy.dto.types import DTOConfig, ExcludeFields, IncludeFields, Purpose
from enum import Enum
from sqlalchemy.orm import DeclarativeBase, QueryableAttribute
from strawchemy.strawberry.dto import EnumDTO, GraphQLFieldDefinition
from strawchemy.dto.base import DTOBackend, DTOBase, DTOFactory, DTOFieldDefinition, Relation
from typing_extensions import override
from typing import TYPE_CHECKING, Any, Optional, TypeVar, cast
class EnumDTOFactory(DTOFactory[DeclarativeBase, QueryableAttribute[Any], EnumDTO]):
inspector: SQLAlchemyGraphQLInspector
def __init__(self, inspector: SQLAlchemyGraphQLInspector, backend: Optional[DTOBackend[EnumDTO]]=None, handle_cycles: bool=True, type_map: Optional[dict[Any, Any]]=None) -> None:
super().__init__(inspector, backend or EnumDTOBackend(), handle_cycles, type_map)
@override
def dto_name(self, base_name: str, dto_config: DTOConfig, node: Optional[Node[Relation[Any, EnumDTO], None]]=None) -> str:
return f'{base_name}Fields'
@override
def should_exclude_field(self, field: DTOFieldDefinition[Any, QueryableAttribute[Any]], dto_config: DTOConfig, node: Node[Relation[Any, EnumDTO], None], has_override: bool) -> bool:
return super().should_exclude_field(field, dto_config, node, has_override) or field.is_relation
@override
def iter_field_definitions(self, name: str, model: type[DeclarativeBase], dto_config: DTOConfig, base: Optional[type[DTOBase[DeclarativeBase]]], node: Node[Relation[DeclarativeBase, EnumDTO], None], raise_if_no_fields: bool=False, **kwargs: Any) -> Generator[DTOFieldDefinition[DeclarativeBase, QueryableAttribute[Any]], None, None]:
for field in super().iter_field_definitions(name, model, dto_config, base, node, raise_if_no_fields, **kwargs):
yield GraphQLFieldDefinition.from_field(field)
@override
def decorator(self, model: type[DeclarativeBase], purpose: Purpose=Purpose.READ, include: Optional[IncludeFields]=None, exclude: Optional[ExcludeFields]=None, partial: Optional[bool]=None, type_map: Optional[Mapping[Any, Any]]=None, aliases: Optional[Mapping[str, str]]=None, alias_generator: Optional[Callable[[str], str]]=None, **kwargs: Any) -> Callable[[type[Any]], type[EnumDTO]]:
return super().decorator(model, purpose, include=include, exclude=exclude, partial=partial, aliases=aliases, alias_generator=alias_generator, type_map=type_map, **kwargs)
def input(self, model: type[DeclarativeBase], include: Optional[IncludeFields]=None, exclude: Optional[ExcludeFields]=None, partial: Optional[bool]=None, type_map: Optional[Mapping[Any, Any]]=None, aliases: Optional[Mapping[str, str]]=None, alias_generator: Optional[Callable[[str], str]]=None, **kwargs: Any) -> Callable[[type[Any]], type[EnumDTO]]:
return super().decorator(model, Purpose.WRITE, include=include, exclude=exclude, partial=partial, aliases=aliases, alias_generator=alias_generator, type_map=type_map, **kwargs)
def upsert_conflict_fields(self, model: type[DeclarativeBase], name: Optional[str]=None) -> type[Enum]:
name = name or f'{model.__name__}ConflictFields'
return cast('type[Enum]', Enum(name, [(f"{'_'.join((col.key for col in constraint.columns))}", constraint) for constraint in self.inspector.unique_constraints(model)]))
|
class EnumDTOFactory(DTOFactory[DeclarativeBase, QueryableAttribute[Any], EnumDTO]):
def __init__(self, inspector: SQLAlchemyGraphQLInspector, backend: Optional[DTOBackend[EnumDTO]]=None, handle_cycles: bool=True, type_map: Optional[dict[Any, Any]]=None) -> None:
pass
@override
def dto_name(self, base_name: str, dto_config: DTOConfig, node: Optional[Node[Relation[Any, EnumDTO], None]]=None) -> str:
pass
@override
def should_exclude_field(self, field: DTOFieldDefinition[Any, QueryableAttribute[Any]], dto_config: DTOConfig, node: Node[Relation[Any, EnumDTO], None], has_override: bool) -> bool:
pass
@override
def iter_field_definitions(self, name: str, model: type[DeclarativeBase], dto_config: DTOConfig, base: Optional[type[DTOBase[DeclarativeBase]]], node: Node[Relation[DeclarativeBase, EnumDTO], None], raise_if_no_fields: bool=False, **kwargs: Any) -> Generator[DTOFieldDefinition[DeclarativeBase, QueryableAttribute[Any]], None, None]:
pass
@override
def decorator(self, model: type[DeclarativeBase], purpose: Purpose=Purpose.READ, include: Optional[IncludeFields]=None, exclude: Optional[ExcludeFields]=None, partial: Optional[bool]=None, type_map: Optional[Mapping[Any, Any]]=None, aliases: Optional[Mapping[str, str]]=None, alias_generator: Optional[Callable[[str], str]]=None, **kwargs: Any) -> Callable[[type[Any]], type[EnumDTO]]:
pass
def input(self, model: type[DeclarativeBase], include: Optional[IncludeFields]=None, exclude: Optional[ExcludeFields]=None, partial: Optional[bool]=None, type_map: Optional[Mapping[Any, Any]]=None, aliases: Optional[Mapping[str, str]]=None, alias_generator: Optional[Callable[[str], str]]=None, **kwargs: Any) -> Callable[[type[Any]], type[EnumDTO]]:
pass
def upsert_conflict_fields(self, model: type[DeclarativeBase], name: Optional[str]=None) -> type[Enum]:
pass
| 12
| 0
| 13
| 0
| 13
| 0
| 1
| 0
| 1
| 21
| 11
| 3
| 7
| 0
| 7
| 22
| 106
| 7
| 99
| 61
| 39
| 0
| 18
| 9
| 10
| 2
| 2
| 1
| 8
|
328,038
|
gazorby/strawchemy
|
/Users/umroot/Documents/PhD_works/PhD-Core-Contents/Class-level-dataset-curation/unseen_data/git_repos_for_analysis/gazorby_strawchemy/src/strawchemy/strawberry/factories/enum.py
|
strawchemy.strawberry.factories.enum.UpsertConflictFieldsEnumDTOBackend
|
from sqlalchemy.orm import DeclarativeBase, QueryableAttribute
from typing_extensions import override
from strawchemy.dto.base import DTOBackend, DTOBase, DTOFactory, DTOFieldDefinition, Relation
from strawchemy.strawberry.dto import EnumDTO, GraphQLFieldDefinition
from typing import TYPE_CHECKING, Any, Optional, TypeVar, cast
from collections.abc import Iterable
class UpsertConflictFieldsEnumDTOBackend(EnumDTOBackend):
def __init__(self, inspector: SQLAlchemyGraphQLInspector, to_camel: bool=True) -> None:
self.dto_base = EnumDTO
self.to_camel = to_camel
self._inspector = inspector
@override
def build(self, name: str, model: type[DeclarativeBase], field_definitions: Iterable[DTOFieldDefinition[DeclarativeBase, QueryableAttribute[Any]]], base: Optional[type[Any]]=None, values: Optional[Iterable[Any]]=None, **kwargs: Any) -> type[EnumDTO]:
constraint_columns = self._inspector.unique_constraints(model)
constraint_map = {column.key: constraint for constraint in constraint_columns for column in constraint.columns}
field_definitions = list(field_definitions)
return super().build(name, model, field_definitions, base, [constraint_map[field.model_field_name] for field in field_definitions], **kwargs)
|
class UpsertConflictFieldsEnumDTOBackend(EnumDTOBackend):
def __init__(self, inspector: SQLAlchemyGraphQLInspector, to_camel: bool=True) -> None:
pass
@override
def build(self, name: str, model: type[DeclarativeBase], field_definitions: Iterable[DTOFieldDefinition[DeclarativeBase, QueryableAttribute[Any]]], base: Optional[type[Any]]=None, values: Optional[Iterable[Any]]=None, **kwargs: Any) -> type[EnumDTO]:
pass
| 4
| 0
| 12
| 0
| 12
| 0
| 1
| 0
| 1
| 9
| 3
| 0
| 2
| 3
| 2
| 32
| 27
| 1
| 26
| 17
| 14
| 0
| 10
| 8
| 7
| 1
| 7
| 0
| 2
|
328,039
|
gazorby/strawchemy
|
/Users/umroot/Documents/PhD_works/PhD-Core-Contents/Class-level-dataset-curation/unseen_data/git_repos_for_analysis/gazorby_strawchemy/src/strawchemy/strawberry/factories/inputs.py
|
strawchemy.strawberry.factories.inputs.AggregateFilterDTOFactory
|
from typing import TYPE_CHECKING, Any, Optional, TypeVar, Union
from strawchemy.strawberry._registry import RegistryTypeInfo
from strawchemy.strawberry.dto import AggregateFieldDefinition, AggregateFilterDTO, AggregationFunctionFilterDTO, BooleanFilterDTO, DTOKey, FilterFunctionInfo, FunctionArgFieldDefinition, FunctionFieldDefinition, GraphQLFieldDefinition, OrderByDTO, OrderByEnum
from strawchemy.dto.base import DTOBackend, DTOBase, DTOFieldDefinition, Relation
from strawchemy.utils import snake_to_camel
from strawchemy.dto.types import DTOConfig, DTOMissing, Purpose
from strawchemy.graph import Node
from .aggregations import AggregationInspector
from sqlalchemy.orm import DeclarativeBase, QueryableAttribute
from strawchemy.dto.backend.strawberry import StrawberrryDTOBackend
from typing_extensions import override
from strawchemy.strawberry.typing import AggregationFunction, GraphQLFilterDTOT, GraphQLPurpose
from strawberry import UNSET
class AggregateFilterDTOFactory(_BaseStrawchemyFilterFactory[AggregateFilterDTO]):
def __init__(self, mapper: Strawchemy, backend: Optional[DTOBackend[AggregateFilterDTO]]=None, handle_cycles: bool=True, type_map: Optional[dict[Any, Any]]=None, aggregation_builder: Optional[AggregationInspector]=None) -> None:
super().__init__(mapper, backend or StrawberrryDTOBackend(AggregateFilterDTO), handle_cycles, type_map)
self.aggregation_builder = aggregation_builder or AggregationInspector(mapper)
self._filter_function_builder = StrawberrryDTOBackend(AggregationFunctionFilterDTO)
@override
def type_description(self) -> str:
return "Boolean expression to compare aggregated fields. All fields are combined with logical 'AND'."
@override
def dto_name(self, base_name: str, dto_config: DTOConfig, node: Optional[Node[Relation[Any, AggregateFilterDTO], None]]=None) -> str:
return f'{base_name}AggregateBoolExp'
def _aggregate_function_type(self, model: type[DeclarativeT], dto_config: DTOConfig, dto_name: str, aggregation: FilterFunctionInfo, model_field: Union[type[DTOMissing], QueryableAttribute[Any]], parent_field_def: Optional[DTOFieldDefinition[DeclarativeBase, QueryableAttribute[Any]]]) -> type[AggregationFunctionFilterDTO]:
dto_config = DTOConfig(Purpose.WRITE)
dto = self._filter_function_builder.build(name=f'{dto_name}{snake_to_camel(aggregation.field_name).capitalize()}', model=model, field_definitions=[FunctionArgFieldDefinition(dto_config=dto_config, model=model, model_field_name='arguments', type_hint=list[aggregation.enum_fields] if aggregation.require_arguments else Optional[list[aggregation.enum_fields]], default_factory=DTOMissing if aggregation.require_arguments else list, _function=aggregation, _model_field=model_field), FunctionFieldDefinition(dto_config=dto_config, model=model, model_field_name='distinct', type_hint=Optional[bool], default=False, _function=aggregation, _model_field=model_field), FunctionFieldDefinition(dto_config=dto_config, model=model, model_field_name='predicate', type_hint=aggregation.comparison_type, _function=aggregation, _model_field=model_field)])
key = DTOKey([model])
dto.__strawchemy_field_map__ = {key + name: FunctionArgFieldDefinition.from_field(field, function=aggregation) for name, field in self.inspector.field_definitions(model, dto_config)}
dto.__strawchemy_description__ = 'Field filtering information'
dto.__dto_function_info__ = aggregation
return self._mapper.registry.register_type(dto, RegistryTypeInfo(dto.__name__, 'input', default_name=self.root_dto_name(model, dto_config)), description=f'Boolean expression to compare {aggregation.function} aggregation.')
@override
def _factory(self, name: str, model: type[DeclarativeT], dto_config: DTOConfig, node: Node[Relation[Any, AggregateFilterDTO], None], base: Optional[type[Any]]=None, parent_field_def: Optional[DTOFieldDefinition[DeclarativeBase, QueryableAttribute[Any]]]=None, raise_if_no_fields: bool=False, backend_kwargs: Optional[dict[str, Any]]=None, **kwargs: Any) -> type[AggregateFilterDTO]:
function_aliases: dict[str, AggregationFunction] = {}
field_defs: list[GraphQLFieldDefinition] = []
model_field = DTOMissing if parent_field_def is None else parent_field_def.model_field
for aggregation in self.aggregation_builder.filter_functions(model, dto_config):
if aggregation.function != aggregation.field_name:
function_aliases[aggregation.field_name] = aggregation.function
type_hint = self._aggregate_function_type(model=model, dto_config=dto_config, dto_name=name, parent_field_def=parent_field_def, model_field=model_field, aggregation=aggregation)
field_defs.append(FunctionFieldDefinition(dto_config=dto_config, model=model, model_field_name=aggregation.field_name, type_hint=Optional[type_hint], default=UNSET, _model_field=model_field, _function=aggregation))
key = DTOKey([model])
dto = self.backend.build(name, model, field_defs, **backend_kwargs or {})
dto.__strawchemy_description__ = "Boolean expression to compare field aggregations. All fields are combined with logical 'AND'."
dto.__strawchemy_field_map__ = {key + field.name: field for field in field_defs}
return dto
|
class AggregateFilterDTOFactory(_BaseStrawchemyFilterFactory[AggregateFilterDTO]):
def __init__(self, mapper: Strawchemy, backend: Optional[DTOBackend[AggregateFilterDTO]]=None, handle_cycles: bool=True, type_map: Optional[dict[Any, Any]]=None, aggregation_builder: Optional[AggregationInspector]=None) -> None:
pass
@override
def type_description(self) -> str:
pass
@override
def dto_name(self, base_name: str, dto_config: DTOConfig, node: Optional[Node[Relation[Any, AggregateFilterDTO], None]]=None) -> str:
pass
def _aggregate_function_type(self, model: type[DeclarativeT], dto_config: DTOConfig, dto_name: str, aggregation: FilterFunctionInfo, model_field: Union[type[DTOMissing], QueryableAttribute[Any]], parent_field_def: Optional[DTOFieldDefinition[DeclarativeBase, QueryableAttribute[Any]]]) -> type[AggregationFunctionFilterDTO]:
pass
@override
def _factory(self, name: str, model: type[DeclarativeT], dto_config: DTOConfig, node: Node[Relation[Any, AggregateFilterDTO], None], base: Optional[type[Any]]=None, parent_field_def: Optional[DTOFieldDefinition[DeclarativeBase, QueryableAttribute[Any]]]=None, raise_if_no_fields: bool=False, backend_kwargs: Optional[dict[str, Any]]=None, **kwargs: Any) -> type[AggregateFilterDTO]:
pass
| 9
| 0
| 24
| 0
| 24
| 0
| 2
| 0
| 1
| 23
| 16
| 0
| 5
| 2
| 5
| 39
| 128
| 4
| 124
| 51
| 84
| 0
| 31
| 17
| 25
| 4
| 5
| 2
| 10
|
328,040
|
gazorby/strawchemy
|
/Users/umroot/Documents/PhD_works/PhD-Core-Contents/Class-level-dataset-curation/unseen_data/git_repos_for_analysis/gazorby_strawchemy/src/strawchemy/strawberry/factories/inputs.py
|
strawchemy.strawberry.factories.inputs.BooleanFilterDTOFactory
|
from strawchemy.dto.base import DTOBackend, DTOBase, DTOFieldDefinition, Relation
from typing import TYPE_CHECKING, Any, Optional, TypeVar, Union
from strawchemy.dto.backend.strawberry import StrawberrryDTOBackend
from strawchemy.strawberry.dto import AggregateFieldDefinition, AggregateFilterDTO, AggregationFunctionFilterDTO, BooleanFilterDTO, DTOKey, FilterFunctionInfo, FunctionArgFieldDefinition, FunctionFieldDefinition, GraphQLFieldDefinition, OrderByDTO, OrderByEnum
class BooleanFilterDTOFactory(_FilterDTOFactory[BooleanFilterDTO]):
def __init__(self, mapper: Strawchemy, backend: Optional[DTOBackend[BooleanFilterDTO]]=None, handle_cycles: bool=True, type_map: Optional[dict[Any, Any]]=None, aggregate_filter_factory: Optional[AggregateFilterDTOFactory]=None, **kwargs: Any) -> None:
super().__init__(mapper, backend or StrawberrryDTOBackend(BooleanFilterDTO), handle_cycles, type_map, aggregation_filter_factory=aggregate_filter_factory, **kwargs)
|
class BooleanFilterDTOFactory(_FilterDTOFactory[BooleanFilterDTO]):
def __init__(self, mapper: Strawchemy, backend: Optional[DTOBackend[BooleanFilterDTO]]=None, handle_cycles: bool=True, type_map: Optional[dict[Any, Any]]=None, aggregate_filter_factory: Optional[AggregateFilterDTOFactory]=None, **kwargs: Any) -> None:
pass
| 2
| 0
| 17
| 0
| 17
| 0
| 1
| 0
| 1
| 8
| 4
| 0
| 1
| 0
| 1
| 42
| 18
| 0
| 18
| 10
| 8
| 0
| 3
| 2
| 1
| 1
| 6
| 0
| 1
|
328,041
|
gazorby/strawchemy
|
/Users/umroot/Documents/PhD_works/PhD-Core-Contents/Class-level-dataset-curation/unseen_data/git_repos_for_analysis/gazorby_strawchemy/src/strawchemy/strawberry/factories/inputs.py
|
strawchemy.strawberry.factories.inputs.OrderByDTOFactory
|
from strawberry import UNSET
from strawchemy.dto.base import DTOBackend, DTOBase, DTOFieldDefinition, Relation
from strawchemy.strawberry._registry import RegistryTypeInfo
from typing import TYPE_CHECKING, Any, Optional, TypeVar, Union
from strawchemy.dto.backend.strawberry import StrawberrryDTOBackend
from strawchemy.dto.types import DTOConfig, DTOMissing, Purpose
from strawchemy.utils import snake_to_camel
from strawchemy.graph import Node
from sqlalchemy.orm import DeclarativeBase, QueryableAttribute
from strawchemy.strawberry.dto import AggregateFieldDefinition, AggregateFilterDTO, AggregationFunctionFilterDTO, BooleanFilterDTO, DTOKey, FilterFunctionInfo, FunctionArgFieldDefinition, FunctionFieldDefinition, GraphQLFieldDefinition, OrderByDTO, OrderByEnum
from typing_extensions import override
class OrderByDTOFactory(_FilterDTOFactory[OrderByDTO]):
def __init__(self, mapper: Strawchemy, backend: Optional[DTOBackend[OrderByDTO]]=None, handle_cycles: bool=True, type_map: Optional[dict[Any, Any]]=None, aggregation_filter_factory: Optional[AggregateFilterDTOFactory]=None) -> None:
super().__init__(mapper, backend or StrawberrryDTOBackend(OrderByDTO), handle_cycles, type_map, aggregation_filter_factory)
@override
def _filter_type(self, field: DTOFieldDefinition[T, ModelFieldT]) -> type[OrderByEnum]:
return OrderByEnum
def _order_by_aggregation_fields(self, aggregation: FilterFunctionInfo, model: type[Any], dto_config: DTOConfig) -> type[OrderByDTO]:
field_defs = [FunctionArgFieldDefinition(dto_config=dto_config, model=model, model_field_name=name.field_definition.name, type_hint=OrderByEnum, _function=aggregation) for name in aggregation.enum_fields]
name = f'{model.__name__}Aggregate{snake_to_camel(aggregation.aggregation_type)}FieldsOrderBy'
dto = self.backend.build(name, model, field_defs)
key = DTOKey([model])
dto.__strawchemy_field_map__ = {key + name: FunctionArgFieldDefinition.from_field(field, function=aggregation) for name, field in self.inspector.field_definitions(model, dto_config)}
return self._mapper.registry.register_type(dto, RegistryTypeInfo(dto.__name__, 'input', default_name=self.root_dto_name(model, dto_config)))
def _order_by_aggregation(self, model: type[Any], dto_config: DTOConfig) -> type[OrderByDTO]:
field_definitions: list[GraphQLFieldDefinition] = []
for aggregation in self._aggregation_filter_factory.aggregation_builder.filter_functions(model, dto_config):
if aggregation.require_arguments:
type_hint = self._order_by_aggregation_fields(aggregation, model, dto_config)
else:
type_hint = OrderByEnum
dto_config = DTOConfig(dto_config.purpose, aliases={aggregation.function: aggregation.field_name}, partial=dto_config.partial, partial_default=UNSET)
field_definitions.append(FunctionFieldDefinition(dto_config=dto_config, model=model, model_field_name=aggregation.field_name, type_hint=Optional[type_hint], default=UNSET, _function=aggregation))
dto = self.backend.build(f'{model.__name__}AggregateOrderBy', model, field_definitions)
dto.__strawchemy_field_map__ = {DTOKey([model, field.name]): field for field in field_definitions}
return self._mapper.registry.register_type(dto, RegistryTypeInfo(dto.__name__, 'input', default_name=self.root_dto_name(model, dto_config)))
@override
def _aggregation_field(self, field_def: DTOFieldDefinition[DeclarativeBase, QueryableAttribute[Any]], dto_config: DTOConfig) -> GraphQLFieldDefinition:
related_model = self.inspector.relation_model(field_def.model_field)
return AggregateFieldDefinition(dto_config=dto_config, model=related_model, _model_field=field_def.model_field, model_field_name=f'{field_def.name}_aggregate', type_hint=Optional[self._order_by_aggregation(related_model, dto_config)], default=UNSET)
@override
def dto_name(self, base_name: str, dto_config: DTOConfig, node: Optional[Node[Relation[Any, OrderByDTO], None]]=None) -> str:
return f'{base_name}OrderBy'
@override
def factory(self, model: type[DeclarativeT], dto_config: DTOConfig, base: Optional[type[Any]]=None, name: Optional[str]=None, parent_field_def: Optional[DTOFieldDefinition[DeclarativeBase, QueryableAttribute[Any]]]=None, current_node: Optional[Node[Relation[Any, OrderByDTO], None]]=None, raise_if_no_fields: bool=False, tags: Optional[set[str]]=None, backend_kwargs: Optional[dict[str, Any]]=None, *, aggregate_filters: bool=True, **kwargs: Any) -> type[OrderByDTO]:
dto = super().factory(model, dto_config, base, name, parent_field_def, current_node, raise_if_no_fields, tags, backend_kwargs, aggregate_filters=aggregate_filters, **kwargs)
dto.__strawchemy_description__ = 'Ordering options'
return dto
|
class OrderByDTOFactory(_FilterDTOFactory[OrderByDTO]):
def __init__(self, mapper: Strawchemy, backend: Optional[DTOBackend[OrderByDTO]]=None, handle_cycles: bool=True, type_map: Optional[dict[Any, Any]]=None, aggregation_filter_factory: Optional[AggregateFilterDTOFactory]=None) -> None:
pass
@override
def _filter_type(self, field: DTOFieldDefinition[T, ModelFieldT]) -> type[OrderByEnum]:
pass
def _order_by_aggregation_fields(self, aggregation: FilterFunctionInfo, model: type[Any], dto_config: DTOConfig) -> type[OrderByDTO]:
pass
def _order_by_aggregation_fields(self, aggregation: FilterFunctionInfo, model: type[Any], dto_config: DTOConfig) -> type[OrderByDTO]:
pass
@override
def _aggregation_field(self, field_def: DTOFieldDefinition[DeclarativeBase, QueryableAttribute[Any]], dto_config: DTOConfig) -> GraphQLFieldDefinition:
pass
@override
def dto_name(self, base_name: str, dto_config: DTOConfig, node: Optional[Node[Relation[Any, OrderByDTO], None]]=None) -> str:
pass
@override
def factory(self, model: type[DeclarativeT], dto_config: DTOConfig, base: Optional[type[Any]]=None, name: Optional[str]=None, parent_field_def: Optional[DTOFieldDefinition[DeclarativeBase, QueryableAttribute[Any]]]=None, current_node: Optional[Node[Relation[Any, OrderByDTO], None]]=None, raise_if_no_fields: bool=False, tags: Optional[set[str]]=None, backend_kwargs: Optional[dict[str, Any]]=None, *, aggregate_filters: bool=True, **kwargs: Any) -> type[OrderByDTO]:
pass
| 12
| 0
| 16
| 0
| 16
| 0
| 1
| 0
| 1
| 23
| 16
| 0
| 7
| 0
| 7
| 48
| 124
| 8
| 116
| 50
| 75
| 0
| 32
| 17
| 24
| 3
| 6
| 2
| 9
|
328,042
|
gazorby/strawchemy
|
/Users/umroot/Documents/PhD_works/PhD-Core-Contents/Class-level-dataset-curation/unseen_data/git_repos_for_analysis/gazorby_strawchemy/src/strawchemy/strawberry/factories/inputs.py
|
strawchemy.strawberry.factories.inputs._BaseStrawchemyFilterFactory
|
from strawchemy.dto.types import DTOConfig, DTOMissing, Purpose
from .base import StrawchemyUnMappedDTOFactory, UnmappedGraphQLDTOT
from typing import TYPE_CHECKING, Any, Optional, TypeVar, Union
from typing_extensions import override
from strawchemy.strawberry.typing import AggregationFunction, GraphQLFilterDTOT, GraphQLPurpose
from collections.abc import Generator, Sequence
class _BaseStrawchemyFilterFactory(StrawchemyUnMappedDTOFactory[UnmappedGraphQLDTOT]):
@classmethod
@override
def graphql_type(cls, dto_config: DTOConfig) -> GraphQLType:
return 'input'
@override
def input(self, model: type[DeclarativeT], *, include: Optional[IncludeFields]=None, exclude: Optional[ExcludeFields]=None, partial: Optional[bool]=None, type_map: Optional[Mapping[Any, Any]]=None, aliases: Optional[Mapping[str, str]]=None, alias_generator: Optional[Callable[[str], str]]=None, name: Optional[str]=None, description: Optional[str]=None, directives: Optional[Sequence[object]]=(), override: bool=False, purpose: Purpose=Purpose.READ, mode: GraphQLPurpose='filter', **kwargs: Any) -> Callable[[type[Any]], type[UnmappedGraphQLDTOT]]:
return self._input_wrapper(model=model, include=include, exclude=exclude, partial=partial, type_map=type_map, aliases=aliases, alias_generator=alias_generator, name=name, description=description, directives=directives, override=override, purpose=purpose, mode=mode, **kwargs)
|
class _BaseStrawchemyFilterFactory(StrawchemyUnMappedDTOFactory[UnmappedGraphQLDTOT]):
@classmethod
@override
def graphql_type(cls, dto_config: DTOConfig) -> GraphQLType:
pass
@override
def input(self, model: type[DeclarativeT], *, include: Optional[IncludeFields]=None, exclude: Optional[ExcludeFields]=None, partial: Optional[bool]=None, type_map: Optional[Mapping[Any, Any]]=None, aliases: Optional[Mapping[str, str]]=None, alias_generator: Optional[Callable[[str], str]]=None, name: Optional[str]=None, description: Optional[str]=None, directives: Optional[Sequence[object]]=(), override:
pass
| 6
| 0
| 17
| 0
| 17
| 0
| 1
| 0
| 1
| 10
| 2
| 2
| 1
| 0
| 2
| 34
| 39
| 1
| 38
| 21
| 16
| 0
| 5
| 3
| 2
| 1
| 4
| 0
| 2
|
328,043
|
gazorby/strawchemy
|
/Users/umroot/Documents/PhD_works/PhD-Core-Contents/Class-level-dataset-curation/unseen_data/git_repos_for_analysis/gazorby_strawchemy/src/strawchemy/strawberry/factories/inputs.py
|
strawchemy.strawberry.factories.inputs._FilterDTOFactory
|
from strawchemy.graph import Node
from collections.abc import Generator, Sequence
from strawchemy.strawberry.typing import AggregationFunction, GraphQLFilterDTOT, GraphQLPurpose
from strawchemy.dto.types import DTOConfig, DTOMissing, Purpose
from strawchemy.dto.base import DTOBackend, DTOBase, DTOFieldDefinition, Relation
from strawberry import UNSET
from strawchemy.strawberry.dto import AggregateFieldDefinition, AggregateFilterDTO, AggregationFunctionFilterDTO, BooleanFilterDTO, DTOKey, FilterFunctionInfo, FunctionArgFieldDefinition, FunctionFieldDefinition, GraphQLFieldDefinition, OrderByDTO, OrderByEnum
from typing import TYPE_CHECKING, Any, Optional, TypeVar, Union
from typing_extensions import override
from sqlalchemy.orm import DeclarativeBase, QueryableAttribute
class _FilterDTOFactory(_BaseStrawchemyFilterFactory[GraphQLFilterDTOT]):
def __init__(self, mapper: Strawchemy, backend: DTOBackend[GraphQLFilterDTOT], handle_cycles: bool=True, type_map: Optional[dict[Any, Any]]=None, aggregation_filter_factory: Optional[AggregateFilterDTOFactory]=None, **kwargs: Any) -> None:
super().__init__(mapper, backend, handle_cycles, type_map, **kwargs)
self._aggregation_filter_factory = aggregation_filter_factory or AggregateFilterDTOFactory(mapper)
def _filter_type(self, field: DTOFieldDefinition[DeclarativeBase, QueryableAttribute[Any]]) -> type[GraphQLFilter]:
return self.inspector.get_field_comparison(field)
def _aggregation_field(self, field_def: DTOFieldDefinition[DeclarativeBase, QueryableAttribute[Any]], dto_config: DTOConfig) -> GraphQLFieldDefinition:
related_model = self.inspector.relation_model(field_def.model_field)
type_hint = self._aggregation_filter_factory.factory(model=related_model, dto_config=dto_config, parent_field_def=field_def)
return AggregateFieldDefinition(dto_config=dto_config, model=related_model, _model_field=field_def.model_field, model_field_name=f'{field_def.name}_aggregate', type_hint=Optional[type_hint], default=UNSET)
@override
def type_description(self) -> str:
return "Boolean expression to compare fields. All fields are combined with logical 'AND'."
@override
def iter_field_definitions(self, name: str, model: type[DeclarativeT], dto_config: DTOConfig, base: Optional[type[DTOBase[DeclarativeBase]]], node: Node[Relation[DeclarativeBase, GraphQLFilterDTOT], None], raise_if_no_fields: bool=False, *, aggregate_filters: bool=False, field_map: Optional[dict[DTOKey, GraphQLFieldDefinition]]=None, **kwargs: Any) -> Generator[DTOFieldDefinition[DeclarativeBase, QueryableAttribute[Any]], None, None]:
field_map = field_map if field_map is not None else {}
for field in super().iter_field_definitions(name, model, dto_config, base, node, raise_if_no_fields, field_map=field_map, **kwargs):
key = DTOKey.from_dto_node(node)
if field.is_relation:
field.type_ = Union[field.type_, None]
if field.uselist and field.related_dto:
field.type_ = Union[field.related_dto, None]
if aggregate_filters:
aggregation_field = self._aggregation_field(field, dto_config.copy_with(partial_default=UNSET))
field_map[key + aggregation_field.name] = aggregation_field
yield aggregation_field
else:
comparison_type = self._filter_type(field)
field.type_ = Optional[comparison_type]
field.default = UNSET
field.default_factory = DTOMissing
yield field
@override
def dto_name(self, base_name: str, dto_config: DTOConfig, node: Optional[Node[Relation[Any, GraphQLFilterDTOT], None]]=None) -> str:
return f'{base_name}BoolExp'
@override
def factory(self, model: type[DeclarativeT], dto_config: DTOConfig, base: Optional[type[Any]]=None, name: Optional[str]=None, parent_field_def: Optional[DTOFieldDefinition[DeclarativeBase, QueryableAttribute[Any]]]=None, current_node: Optional[Node[Relation[Any, GraphQLFilterDTOT], None]]=None, raise_if_no_fields: bool=False, tags: Optional[set[str]]=None, backend_kwargs: Optional[dict[str, Any]]=None, *, aggregate_filters: bool=True, **kwargs: Any) -> type[GraphQLFilterDTOT]:
return super().factory(model, dto_config, base, name, parent_field_def, current_node, raise_if_no_fields, tags, backend_kwargs, aggregate_filters=aggregate_filters, **kwargs)
|
class _FilterDTOFactory(_BaseStrawchemyFilterFactory[GraphQLFilterDTOT]):
def __init__(self, mapper: Strawchemy, backend: DTOBackend[GraphQLFilterDTOT], handle_cycles: bool=True, type_map: Optional[dict[Any, Any]]=None, aggregation_filter_factory: Optional[AggregateFilterDTOFactory]=None, **kwargs: Any) -> None:
pass
def _filter_type(self, field: DTOFieldDefinition[DeclarativeBase, QueryableAttribute[Any]]) -> type[GraphQLFilter]:
pass
def _aggregation_field(self, field_def: DTOFieldDefinition[DeclarativeBase, QueryableAttribute[Any]], dto_config: DTOConfig) -> GraphQLFieldDefinition:
pass
@override
def type_description(self) -> str:
pass
@override
def iter_field_definitions(self, name: str, model: type[DeclarativeT], dto_config: DTOConfig, base: Optional[type[DTOBase[DeclarativeBase]]], node: Node[Relation[DeclarativeBase, GraphQLFilterDTOT], None], raise_if_no_fields: bool=False, *, aggregate_filters: bool=False, field_map: Optional[dict[DTOKey, GraphQLFieldDefinition]]=None, **kwargs: Any) -> Generator[DTOFieldDefinition[DeclarativeBase, QueryableAttribute[Any]], None, None]:
pass
@override
def dto_name(self, base_name: str, dto_config: DTOConfig, node: Optional[Node[Relation[Any, GraphQLFilterDTOT], None]]=None) -> str:
pass
@override
def factory(self, model: type[DeclarativeT], dto_config: DTOConfig, base: Optional[type[Any]]=None, name: Optional[str]=None, parent_field_def: Optional[DTOFieldDefinition[DeclarativeBase, QueryableAttribute[Any]]]=None, current_node: Optional[Node[Relation[Any, GraphQLFilterDTOT], None]]=None, raise_if_no_fields: bool=False, tags: Optional[set[str]]=None, backend_kwargs: Optional[dict[str, Any]]=None, *, aggregate_filters: bool=True, **kwargs: Any) -> type[GraphQLFilterDTOT]:
pass
| 12
| 0
| 13
| 0
| 13
| 0
| 2
| 0
| 1
| 18
| 11
| 2
| 7
| 1
| 7
| 41
| 104
| 7
| 97
| 56
| 48
| 0
| 33
| 15
| 25
| 6
| 5
| 3
| 12
|
328,044
|
gazorby/strawchemy
|
/Users/umroot/Documents/PhD_works/PhD-Core-Contents/Class-level-dataset-curation/unseen_data/git_repos_for_analysis/gazorby_strawchemy/src/strawchemy/strawberry/factories/types.py
|
strawchemy.strawberry.factories.types.AggregateDTOFactory
|
from strawchemy.strawberry.dto import AggregateDTO, AggregateFieldDefinition, DTOKey, EnumDTO, FunctionFieldDefinition, GraphQLFieldDefinition, MappedStrawberryGraphQLDTO
from sqlalchemy.orm import DeclarativeBase, QueryableAttribute
from .base import GraphQLDTOFactory, MappedGraphQLDTOT, StrawchemyMappedFactory, _ChildOptions
from typing import TYPE_CHECKING, Any, Optional, TypeVar, Union
from strawchemy.graph import Node
from typing_extensions import Self, override
from .aggregations import AggregationInspector
from strawchemy.strawberry.typing import AggregateDTOT, GraphQLDTOT, GraphQLPurpose
from strawchemy.dto.types import DTOConfig, DTOMissing, Purpose
class AggregateDTOFactory(GraphQLDTOFactory[AggregateDTOT]):
def __init__(self, mapper: Strawchemy, backend: DTOBackend[AggregateDTOT], handle_cycles: bool=True, type_map: Optional[dict[Any, Any]]=None, aggregation_builder: Optional[AggregationInspector]=None, **kwargs: Any) -> None:
super().__init__(mapper, backend, handle_cycles, type_map, **kwargs)
self._aggregation_builder = aggregation_builder or AggregationInspector(mapper)
@override
def type_description(self) -> str:
return 'Aggregation fields'
@override
def dto_name(self, base_name: str, dto_config: DTOConfig, node: Optional[Node[Relation[Any, AggregateDTOT], None]]=None) -> str:
return f'{base_name}Aggregate'
@override
def _factory(self, name: str, model: type[DeclarativeT], dto_config: DTOConfig, node: Node[Relation[Any, AggregateDTOT], None], base: Optional[type[Any]]=None, parent_field_def: Optional[DTOFieldDefinition[DeclarativeBase, QueryableAttribute[Any]]]=None, raise_if_no_fields: bool=False, backend_kwargs: Optional[dict[str, Any]]=None, field_map: Optional[dict[DTOKey, GraphQLFieldDefinition]]=None, **kwargs: Any) -> type[AggregateDTOT]:
field_map = field_map if field_map is not None else {}
model_field = parent_field_def.model_field if parent_field_def else None
aggregate_config = dto_config.copy_with(partial=True, include='all')
field_definitions: list[FunctionFieldDefinition] = [FunctionFieldDefinition(dto_config=dto_config, model=model, _model_field=model_field if model_field is not None else DTOMissing, model_field_name=aggregation.function, type_hint=aggregation.output_type, _function=aggregation, default=aggregation.default) for aggregation in self._aggregation_builder.output_functions(model, aggregate_config)]
root_key = DTOKey.from_dto_node(node)
field_map.update({root_key + field.model_field_name: field for field in field_definitions})
return self.backend.build(name, model, field_definitions, **backend_kwargs or {})
|
class AggregateDTOFactory(GraphQLDTOFactory[AggregateDTOT]):
def __init__(self, mapper: Strawchemy, backend: DTOBackend[AggregateDTOT], handle_cycles: bool=True, type_map: Optional[dict[Any, Any]]=None, aggregation_builder: Optional[AggregationInspector]=None, **kwargs: Any) -> None:
pass
@override
def type_description(self) -> str:
pass
@override
def dto_name(self, base_name: str, dto_config: DTOConfig, node: Optional[Node[Relation[Any, AggregateDTOT], None]]=None) -> str:
pass
@override
def _factory(self, name: str, model: type[DeclarativeT], dto_config: DTOConfig, node: Node[Relation[Any, AggregateDTOT], None], base: Optional[type[Any]]=None, parent_field_def: Optional[DTOFieldDefinition[DeclarativeBase, QueryableAttribute[Any]]]=None, raise_if_no_fields: bool=False, backend_kwargs: Optional[dict[str, Any]]=None, field_map: Optional[dict[DTOKey, GraphQLFieldDefinition]]=None, **kwargs: Any) -> type[AggregateDTOT]:
pass
| 8
| 0
| 12
| 0
| 12
| 0
| 2
| 0
| 1
| 17
| 10
| 0
| 4
| 1
| 4
| 34
| 56
| 4
| 52
| 35
| 22
| 0
| 16
| 10
| 11
| 4
| 3
| 0
| 7
|
328,045
|
gazorby/strawchemy
|
/Users/umroot/Documents/PhD_works/PhD-Core-Contents/Class-level-dataset-curation/unseen_data/git_repos_for_analysis/gazorby_strawchemy/src/strawchemy/strawberry/factories/types.py
|
strawchemy.strawberry.factories.types.DistinctOnFieldsDTOFactory
|
from typing import TYPE_CHECKING, Any, Optional, TypeVar, Union
from strawchemy.strawberry.dto import AggregateDTO, AggregateFieldDefinition, DTOKey, EnumDTO, FunctionFieldDefinition, GraphQLFieldDefinition, MappedStrawberryGraphQLDTO
from strawchemy.dto.types import DTOConfig, DTOMissing, Purpose
from strawchemy.graph import Node
from typing_extensions import Self, override
from .enum import EnumDTOFactory, UpsertConflictFieldsEnumDTOBackend
class DistinctOnFieldsDTOFactory(EnumDTOFactory):
@override
def dto_name(self, base_name: str, dto_config: DTOConfig, node: Optional[Node[Relation[Any, EnumDTO], None]]=None) -> str:
return f'{base_name}DistinctOnFields'
|
class DistinctOnFieldsDTOFactory(EnumDTOFactory):
@override
def dto_name(self, base_name: str, dto_config: DTOConfig, node: Optional[Node[Relation[Any, EnumDTO], None]]=None) -> str:
pass
| 3
| 0
| 4
| 0
| 4
| 0
| 1
| 0
| 1
| 6
| 4
| 0
| 1
| 0
| 1
| 23
| 6
| 0
| 6
| 5
| 1
| 0
| 3
| 2
| 1
| 1
| 3
| 0
| 1
|
328,046
|
gazorby/strawchemy
|
/Users/umroot/Documents/PhD_works/PhD-Core-Contents/Class-level-dataset-curation/unseen_data/git_repos_for_analysis/gazorby_strawchemy/src/strawchemy/strawberry/factories/types.py
|
strawchemy.strawberry.factories.types.InputFactory
|
from .enum import EnumDTOFactory, UpsertConflictFieldsEnumDTOBackend
from strawchemy.dto.types import DTOConfig, DTOMissing, Purpose
from sqlalchemy.orm import DeclarativeBase, QueryableAttribute
from strawchemy.utils import get_annotations, non_optional_type_hint, snake_to_camel
from .base import GraphQLDTOFactory, MappedGraphQLDTOT, StrawchemyMappedFactory, _ChildOptions
from strawchemy.dto.base import DTOFactory, MappedDTO
from typing import TYPE_CHECKING, Any, Optional, TypeVar, Union
from strawchemy.strawberry.mutation.types import RequiredToManyUpdateInput, RequiredToOneInput, ToManyCreateInput, ToManyUpdateInput, ToOneInput
from strawchemy.dto.exceptions import EmptyDTOError
from strawchemy.graph import Node
from strawchemy.strawberry.dto import AggregateDTO, AggregateFieldDefinition, DTOKey, EnumDTO, FunctionFieldDefinition, GraphQLFieldDefinition, MappedStrawberryGraphQLDTO
from collections.abc import Generator
from strawchemy.dto.backend.strawberry import StrawberrryDTOBackend
from strawchemy.dto.utils import read_all_partial_config, read_partial, write_all_config
from strawchemy.strawberry.typing import AggregateDTOT, GraphQLDTOT, GraphQLPurpose
from typing_extensions import Self, override
class InputFactory(TypeDTOFactory[MappedGraphQLDTOT]):
def __init__(self, mapper: Strawchemy, backend: DTOBackend[MappedGraphQLDTOT], handle_cycles: bool=True, type_map: Optional[dict[Any, Any]]=None, **kwargs: Any) -> None:
super().__init__(mapper, backend, handle_cycles, type_map, **kwargs)
self._identifier_input_dto_builder = StrawberrryDTOBackend(MappedStrawberryGraphQLDTO[DeclarativeBase])
self._identifier_input_dto_factory = DTOFactory(self.inspector, self.backend)
self._upsert_update_fields_enum_factory = EnumDTOFactory(self.inspector)
self._upsert_conflict_fields_enum_factory = UpsertConflictFieldsDTOFactory(self.inspector)
def _identifier_input(self, field: DTOFieldDefinition[DeclarativeBase, QueryableAttribute[Any]], node: Node[Relation[DeclarativeBase, MappedGraphQLDTOT], None]) -> type[MappedDTO[Any]]:
name = f'{node.root.value.model.__name__}{snake_to_camel(field.name)}IdFieldsInput'
related_model = field.related_model
assert related_model
id_fields = list(self.inspector.id_field_definitions(related_model, write_all_config))
dto_config = DTOConfig(Purpose.WRITE, include={name for name, _ in id_fields}, exclude_from_scope=True)
base = self._identifier_input_dto_factory.dtos.get(name)
if base is None:
try:
base = self._identifier_input_dto_factory.factory(related_model, dto_config, name=name, raise_if_no_fields=True)
except EmptyDTOError as error:
msg = f'Cannot generate `{name}` input type from `{related_model.__name__}` model because primary key columns are disabled for write purpose'
raise EmptyDTOError(msg) from error
return self._register_type(base, dto_config, node, description='Identifier input', user_defined=False)
def _upsert_udpate_fields(self, field: DTOFieldDefinition[DeclarativeBase, QueryableAttribute[Any]], node: Node[Relation[DeclarativeBase, MappedGraphQLDTOT], None], dto_config: DTOConfig) -> type[EnumDTO]:
name = f'{node.root.value.model.__name__}{snake_to_camel(field.name)}UpdateFields'
related_model = field.related_model
assert related_model
update_fields = self._upsert_update_fields_enum_factory.factory(related_model, dto_config.copy_with(purpose=Purpose.WRITE, include='all'), name=name)
return self._mapper.registry.register_enum(update_fields, name=name, description='Update fields enum')
def _upsert_conflict_fields(self, field: DTOFieldDefinition[DeclarativeBase, QueryableAttribute[Any]], node: Node[Relation[DeclarativeBase, MappedGraphQLDTOT], None], dto_config: DTOConfig) -> type[Enum]:
name = f'{node.root.value.model.__name__}{snake_to_camel(field.name)}ConflictFields'
related_model = field.related_model
assert related_model
conflict_fields = self._upsert_conflict_fields_enum_factory.factory(related_model, dto_config.copy_with(purpose=Purpose.WRITE, include='all'), name=name)
return self._mapper.registry.register_enum(conflict_fields, name=name, description='Conflict fields enum')
def _description(self, mode: GraphQLPurpose) -> str:
if mode == 'create_input':
return 'Create input'
if mode == 'update_by_pk_input':
return 'Identifier update input'
if mode == 'update_by_filter_input':
return 'Filter update input'
return 'Input'
@override
def _cache_key(self, model: type[Any], dto_config: DTOConfig, node: Node[Relation[Any, MappedGraphQLDTOT], None], *, child_options: _ChildOptions, mode: GraphQLPurpose, **factory_kwargs: Any) -> Hashable:
return (super()._cache_key(model, dto_config, node, child_options=child_options, **factory_kwargs), node.root.value.model, mode)
@override
def type_description(self) -> str:
return 'GraphQL input type'
@override
def dto_name(self, base_name: str, dto_config: DTOConfig, node: Optional[Node[Relation[Any, MappedGraphQLDTOT], None]]=None) -> str:
return f"{(node.root.value.model.__name__ if node else '')}{base_name}Input"
@override
def should_exclude_field(self, field: DTOFieldDefinition[Any, QueryableAttribute[Any]], dto_config: DTOConfig, node: Node[Relation[Any, MappedGraphQLDTOT], None], has_override: bool) -> bool:
return super().should_exclude_field(field, dto_config, node, has_override) or self.inspector.is_foreign_key(field.model_field) or self.inspector.relation_cycle(field, node)
@override
def _resolve_type(self, field: DTOFieldDefinition[DeclarativeBase, QueryableAttribute[Any]], dto_config: DTOConfig, node: Node[Relation[DeclarativeBase, MappedGraphQLDTOT], None], *, mode: GraphQLPurpose, **factory_kwargs: Any) -> Any:
if not field.is_relation:
return super()._resolve_basic_type(field, dto_config)
self._resolve_relation_type(field, dto_config, node, mode=mode, **factory_kwargs)
identifier_input = self._identifier_input(field, node)
field_required = self.inspector.required(field.model_field)
upsert_update_fields = self._upsert_udpate_fields(field, node, dto_config)
upsert_conflict_fields = self._upsert_conflict_fields(field, node, dto_config)
if field.uselist:
if mode == 'create_input':
input_type = ToManyCreateInput[identifier_input, field.related_dto, upsert_update_fields, upsert_conflict_fields]
else:
type_ = RequiredToManyUpdateInput if self.inspector.reverse_relation_required(field.model_field) else ToManyUpdateInput
input_type = type_[identifier_input, field.related_dto, upsert_update_fields, upsert_conflict_fields]
else:
type_ = RequiredToOneInput if field_required else ToOneInput
input_type = type_[identifier_input, field.related_dto, upsert_update_fields, upsert_conflict_fields]
return input_type if field_required and mode == 'create_input' else Optional[input_type]
@override
def iter_field_definitions(self, name: str, model: type[DeclarativeT], dto_config: DTOConfig, base: Optional[type[DTOBase[DeclarativeBase]]], node: Node[Relation[DeclarativeBase, MappedGraphQLDTOT], None], raise_if_no_fields: bool=False, *, mode: GraphQLPurpose, **factory_kwargs: Any) -> Generator[DTOFieldDefinition[DeclarativeBase, QueryableAttribute[Any]], None, None]:
for field in super().iter_field_definitions(name, model, dto_config, base, node, raise_if_no_fields, mode=mode, **factory_kwargs):
if mode == 'update_by_pk_input' and self.inspector.is_primary_key(field.model_field):
field.type_ = non_optional_type_hint(field.type_)
yield field
@override
def factory(self, model: type[DeclarativeT], dto_config: DTOConfig=read_partial, base: Optional[type[Any]]=None, name: Optional[str]=None, parent_field_def: Optional[DTOFieldDefinition[DeclarativeBase, QueryableAttribute[Any]]]=None, current_node: Optional[Node[Relation[Any, MappedGraphQLDTOT], None]]=None, raise_if_no_fields: bool=False, tags: Optional[set[str]]=None, backend_kwargs: Optional[dict[str, Any]]=None, *, description: Optional[str]=None, mode: GraphQLPurpose, **kwargs: Any) -> type[MappedGraphQLDTOT]:
return super().factory(model, dto_config, base, name, parent_field_def, current_node, raise_if_no_fields, tags=tags or set() | {mode}, backend_kwargs=backend_kwargs, description=description or self._description(mode), mode=mode, **kwargs)
|
class InputFactory(TypeDTOFactory[MappedGraphQLDTOT]):
def __init__(self, mapper: Strawchemy, backend: DTOBackend[MappedGraphQLDTOT], handle_cycles: bool=True, type_map: Optional[dict[Any, Any]]=None, **kwargs: Any) -> None:
pass
def _identifier_input(self, field: DTOFieldDefinition[DeclarativeBase, QueryableAttribute[Any]], node: Node[Relation[DeclarativeBase, MappedGraphQLDTOT], None]) -> type[MappedDTO[Any]]:
pass
def _upsert_udpate_fields(self, field: DTOFieldDefinition[DeclarativeBase, QueryableAttribute[Any]], node: Node[Relation[DeclarativeBase, MappedGraphQLDTOT], None], dto_config: DTOConfig) -> type[EnumDTO]:
pass
def _upsert_conflict_fields(self, field: DTOFieldDefinition[DeclarativeBase, QueryableAttribute[Any]], node: Node[Relation[DeclarativeBase, MappedGraphQLDTOT], None], dto_config: DTOConfig) -> type[Enum]:
pass
def _description(self, mode: GraphQLPurpose) -> str:
pass
@override
def _cache_key(self, model: type[Any], dto_config: DTOConfig, node: Node[Relation[Any, MappedGraphQLDTOT], None], *, child_options: _ChildOptions, mode: GraphQLPurpose, **factory_kwargs: Any) -> Hashable:
pass
@override
def type_description(self) -> str:
pass
@override
def dto_name(self, base_name: str, dto_config: DTOConfig, node: Optional[Node[Relation[Any, MappedGraphQLDTOT], None]]=None) -> str:
pass
@override
def should_exclude_field(self, field: DTOFieldDefinition[Any, QueryableAttribute[Any]], dto_config: DTOConfig, node: Node[Relation[Any, MappedGraphQLDTOT], None], has_override: bool) -> bool:
pass
@override
def _resolve_type(self, field: DTOFieldDefinition[DeclarativeBase, QueryableAttribute[Any]], dto_config: DTOConfig, node: Node[Relation[DeclarativeBase, MappedGraphQLDTOT], None], *, mode: GraphQLPurpose, **factory_kwargs: Any) -> Any:
pass
@override
def iter_field_definitions(self, name: str, model: type[DeclarativeT], dto_config: DTOConfig, base: Optional[type[DTOBase[DeclarativeBase]]], node: Node[Relation[DeclarativeBase, MappedGraphQLDTOT], None], raise_if_no_fields: bool=False, *, mode: GraphQLPurpose, **factory_kwargs: Any) -> Generator[DTOFieldDefinition[DeclarativeBase, QueryableAttribute[Any]], None, None]:
pass
@override
def factory(self, model: type[DeclarativeT], dto_config: DTOConfig=read_partial, base: Optional[type[Any]]=None, name: Optional[str]=None, parent_field_def: Optional[DTOFieldDefinition[DeclarativeBase, QueryableAttribute[Any]]]=None, current_node: Optional[Node[Relation[Any, MappedGraphQLDTOT], None]]=None, raise_if_no_fields: bool=False, tags: Optional[set[str]]=None, backend_kwargs: Optional[dict[str, Any]]=None, *, description: Optional[str]=None, mode: GraphQLPurpose, **kwargs: Any) -> type[MappedGraphQLDTOT]:
pass
| 20
| 0
| 17
| 0
| 16
| 0
| 2
| 0.02
| 1
| 30
| 20
| 1
| 11
| 4
| 11
| 52
| 200
| 12
| 188
| 117
| 95
| 3
| 64
| 35
| 52
| 7
| 5
| 2
| 22
|
328,047
|
gazorby/strawchemy
|
/Users/umroot/Documents/PhD_works/PhD-Core-Contents/Class-level-dataset-curation/unseen_data/git_repos_for_analysis/gazorby_strawchemy/src/strawchemy/strawberry/factories/types.py
|
strawchemy.strawberry.factories.types.RootAggregateTypeDTOFactory
|
from sqlalchemy.orm import DeclarativeBase, QueryableAttribute
from strawchemy.strawberry.dto import AggregateDTO, AggregateFieldDefinition, DTOKey, EnumDTO, FunctionFieldDefinition, GraphQLFieldDefinition, MappedStrawberryGraphQLDTO
from strawchemy.dto.backend.strawberry import StrawberrryDTOBackend
from strawchemy.dto.types import DTOConfig, DTOMissing, Purpose
from typing import TYPE_CHECKING, Any, Optional, TypeVar, Union
from strawchemy.graph import Node
from collections.abc import Generator
from .base import GraphQLDTOFactory, MappedGraphQLDTOT, StrawchemyMappedFactory, _ChildOptions
from typing_extensions import Self, override
from strawchemy.constants import AGGREGATIONS_KEY, JSON_PATH_KEY, NODES_KEY
from strawchemy.strawberry.typing import AggregateDTOT, GraphQLDTOT, GraphQLPurpose
class RootAggregateTypeDTOFactory(TypeDTOFactory[MappedGraphQLDTOT]):
def __init__(self, mapper: Strawchemy, backend: DTOBackend[MappedGraphQLDTOT], handle_cycles: bool=True, type_map: Optional[dict[Any, Any]]=None, type_factory: Optional[TypeDTOFactory[MappedGraphQLDTOT]]=None, aggregation_factory: Optional[AggregateDTOFactory[AggregateDTOT]]=None, **kwargs: Any) -> None:
super().__init__(mapper, backend, handle_cycles, type_map, **kwargs)
self._type_factory = type_factory or TypeDTOFactory(mapper, backend)
self._aggregation_factory = aggregation_factory or AggregateDTOFactory(mapper, StrawberrryDTOBackend(AggregateDTO))
@override
def dto_name(self, base_name: str, dto_config: DTOConfig, node: Optional[Node[Relation[Any, MappedGraphQLDTOT], None]]=None) -> str:
return f'{base_name}Root'
@override
def iter_field_definitions(self, name: str, model: type[DeclarativeT], dto_config: DTOConfig, base: Optional[type[DTOBase[DeclarativeBase]]], node: Node[Relation[DeclarativeBase, MappedGraphQLDTOT], None], raise_if_no_fields: bool=False, aggregations: bool=False, field_map: Optional[dict[DTOKey, GraphQLFieldDefinition]]=None, **kwargs: Any) -> Generator[DTOFieldDefinition[DeclarativeBase, QueryableAttribute[Any]], None, None]:
if not node.is_root:
yield from ()
key = DTOKey.from_dto_node(node)
field_map = field_map if field_map is not None else {}
nodes_dto = self._type_factory.factory(model, dto_config=dto_config, aggregations=aggregations)
nodes = GraphQLFieldDefinition(dto_config=dto_config, model=model, model_field_name=NODES_KEY, type_hint=list[nodes_dto], is_relation=False)
aggregations_field = GraphQLFieldDefinition(dto_config=dto_config, model=model, model_field_name=AGGREGATIONS_KEY, type_hint=self._aggregation_factory.factory(model, dto_config=dto_config), is_relation=False, is_aggregate=True)
field_map[key + nodes.name] = nodes
field_map[key + aggregations_field.name] = aggregations_field
yield from iter((nodes, aggregations_field))
@override
def factory(self, model: type[DeclarativeT], dto_config: DTOConfig, base: Optional[type[Any]]=None, name: Optional[str]=None, parent_field_def: Optional[DTOFieldDefinition[DeclarativeBase, QueryableAttribute[Any]]]=None, current_node: Optional[Node[Relation[Any, MappedGraphQLDTOT], None]]=None, raise_if_no_fields: bool=False, tags: Optional[set[str]]=None, backend_kwargs: Optional[dict[str, Any]]=None, *, aggregations: bool=True, **kwargs: Any) -> type[MappedGraphQLDTOT]:
dto = super().factory(model, dto_config, base, name, parent_field_def, current_node, raise_if_no_fields, tags, backend_kwargs, aggregations=aggregations, **kwargs)
dto.__strawchemy_is_root_aggregation_type__ = True
return dto
|
class RootAggregateTypeDTOFactory(TypeDTOFactory[MappedGraphQLDTOT]):
def __init__(self, mapper: Strawchemy, backend: DTOBackend[MappedGraphQLDTOT], handle_cycles: bool=True, type_map: Optional[dict[Any, Any]]=None, type_factory: Optional[TypeDTOFactory[MappedGraphQLDTOT]]=None, aggregation_factory: Optional[AggregateDTOFactory[AggregateDTOT]]=None, **kwargs: Any) -> None:
pass
@override
def dto_name(self, base_name: str, dto_config: DTOConfig, node: Optional[Node[Relation[Any, MappedGraphQLDTOT], None]]=None) -> str:
pass
@override
def iter_field_definitions(self, name: str, model: type[DeclarativeT], dto_config: DTOConfig, base: Optional[type[DTOBase[DeclarativeBase]]], node: Node[Relation[DeclarativeBase, MappedGraphQLDTOT], None], raise_if_no_fields: bool=False, aggregations: bool=False, field_map: Optional[dict[DTOKey, GraphQLFieldDefinition]]=None, **kwargs: Any) -> Generator[DTOFieldDefinition[DeclarativeBase, QueryableAttribute[Any]], None, None]:
pass
@override
def factory(self, model: type[DeclarativeT], dto_config: DTOConfig, base: Optional[type[Any]]=None, name: Optional[str]=None, parent_field_def: Optional[DTOFieldDefinition[DeclarativeBase, QueryableAttribute[Any]]]=None, current_node: Optional[Node[Relation[Any, MappedGraphQLDTOT], None]]=None, raise_if_no_fields: bool=False, tags: Optional[set[str]]=None, backend_kwargs: Optional[dict[str, Any]]=None, *, aggregations: bool=True, **kwargs: Any) -> type[MappedGraphQLDTOT]:
pass
| 8
| 0
| 21
| 0
| 21
| 0
| 2
| 0
| 1
| 19
| 11
| 0
| 4
| 2
| 4
| 45
| 89
| 3
| 86
| 50
| 43
| 0
| 22
| 12
| 17
| 3
| 5
| 1
| 6
|
328,048
|
gazorby/strawchemy
|
/Users/umroot/Documents/PhD_works/PhD-Core-Contents/Class-level-dataset-curation/unseen_data/git_repos_for_analysis/gazorby_strawchemy/src/strawchemy/strawberry/factories/types.py
|
strawchemy.strawberry.factories.types.TypeDTOFactory
|
from .inputs import OrderByDTOFactory
from strawchemy.constants import AGGREGATIONS_KEY, JSON_PATH_KEY, NODES_KEY
from typing_extensions import Self, override
from collections.abc import Generator
from strawberry.annotation import StrawberryAnnotation
from strawchemy.dto.types import DTOConfig, DTOMissing, Purpose
from strawchemy.strawberry.typing import AggregateDTOT, GraphQLDTOT, GraphQLPurpose
from .base import GraphQLDTOFactory, MappedGraphQLDTOT, StrawchemyMappedFactory, _ChildOptions
from __future__ import annotations
from strawchemy.dto.utils import read_all_partial_config, read_partial, write_all_config
from strawberry.types.arguments import StrawberryArgument
from strawchemy.utils import get_annotations, non_optional_type_hint, snake_to_camel
from strawchemy.dto.backend.strawberry import StrawberrryDTOBackend
from sqlalchemy import JSON
from strawchemy.strawberry.dto import AggregateDTO, AggregateFieldDefinition, DTOKey, EnumDTO, FunctionFieldDefinition, GraphQLFieldDefinition, MappedStrawberryGraphQLDTO
from strawchemy.graph import Node
from typing import TYPE_CHECKING, Any, Optional, TypeVar, Union
from sqlalchemy.orm import DeclarativeBase, QueryableAttribute
class TypeDTOFactory(StrawchemyMappedFactory[MappedGraphQLDTOT]):
def __init__(self, mapper: Strawchemy, backend: DTOBackend[MappedGraphQLDTOT], handle_cycles: bool=True, type_map: Optional[dict[Any, Any]]=None, aggregation_factory: Optional[AggregateDTOFactory[AggregateDTOT]]=None, order_by_factory: Optional[OrderByDTOFactory]=None, **kwargs: Any) -> None:
super().__init__(mapper, backend, handle_cycles, type_map, **kwargs)
self._aggregation_factory = aggregation_factory or AggregateDTOFactory(mapper, StrawberrryDTOBackend(AggregateDTO))
self._order_by_factory = order_by_factory or OrderByDTOFactory(mapper, handle_cycles=handle_cycles, type_map=type_map)
def _aggregation_field(self, field_def: DTOFieldDefinition[DeclarativeBase, QueryableAttribute[Any]], dto_config: DTOConfig) -> GraphQLFieldDefinition:
related_model = self.inspector.relation_model(field_def.model_field)
aggregate_dto_config = dto_config.copy_with(annotation_overrides={})
dto = self._aggregation_factory.factory(model=related_model, dto_config=aggregate_dto_config, parent_field_def=field_def)
return AggregateFieldDefinition(dto_config=dto_config, model=dto.__dto_model__, _model_field=field_def.model_field, model_field_name=f'{field_def.name}_aggregate', type_hint=dto, related_dto=dto)
def _update_fields(self, dto: type[GraphQLDTOT], base: Optional[type[Any]], pagination: Union[bool, DefaultOffsetPagination]=False, order_by: bool=False) -> type[GraphQLDTOT]:
attributes: dict[str, Any] = {}
annotations: dict[str, Any] = {}
for field in dto.__strawchemy_field_map__.values():
if field.is_relation and field.uselist:
related = Self if field.related_dto is dto else field.related_dto
type_annotation = list[related] if related is not None else field.type_
assert field.related_model
order_by_input = None
if order_by:
order_by_input = self._order_by_factory.factory(field.related_model, read_all_partial_config)
strawberry_field = self._mapper.field(pagination=pagination, order_by=order_by_input, root_field=False)
attributes[field.name] = strawberry_field
annotations[field.name] = type_annotation
elif not field.is_relation and field.has_model_field and (self.inspector.model_field_type(field) in {JSON, dict}):
attributes[field.name] = self._mapper.field(root_field=False, arguments=[StrawberryArgument(JSON_PATH_KEY, None, type_annotation=StrawberryAnnotation(annotation=Optional[str]))])
annotations[field.name] = Union[field.type_, None]
dto.__annotations__ |= annotations
for name, value in attributes.items():
setattr(dto, name, value)
if base:
dto.__annotations__ |= get_annotations(base)
for name, value in get_annotations(base).items():
if not hasattr(base, name):
continue
setattr(dto, name, value)
return dto
@override
def _cache_key(self, model: type[Any], dto_config: DTOConfig, node: Node[Relation[Any, MappedGraphQLDTOT], None], *, child_options: _ChildOptions, **factory_kwargs: Any) -> Hashable:
return (super()._cache_key(model, dto_config, node, **factory_kwargs), child_options)
@override
def dto_name(self, base_name: str, dto_config: DTOConfig, node: Optional[Node[Relation[Any, MappedGraphQLDTOT], None]]=None) -> str:
return f"{base_name}{('Input' if dto_config.purpose is Purpose.WRITE else '')}Type"
@override
def iter_field_definitions(self, name: str, model: type[DeclarativeT], dto_config: DTOConfig, base: Optional[type[DTOBase[DeclarativeBase]]], node: Node[Relation[DeclarativeBase, MappedGraphQLDTOT], None], raise_if_no_fields: bool=False, *, aggregations: bool=False, field_map: Optional[dict[DTOKey, GraphQLFieldDefinition]]=None, **kwargs: Any) -> Generator[DTOFieldDefinition[DeclarativeBase, QueryableAttribute[Any]], None, None]:
field_map = field_map if field_map is not None else {}
for field in super().iter_field_definitions(name, model, dto_config, base, node, raise_if_no_fields, field_map=field_map, **kwargs):
key = DTOKey.from_dto_node(node)
if field.is_relation and field.uselist and aggregations:
aggregation_field = self._aggregation_field(field, dto_config)
field_map[key + aggregation_field.name] = aggregation_field
yield aggregation_field
yield field
@override
def factory(self, model: type[DeclarativeT], dto_config: DTOConfig, base: Optional[type[Any]]=None, name: Optional[str]=None, parent_field_def: Optional[DTOFieldDefinition[DeclarativeBase, QueryableAttribute[Any]]]=None, current_node: Optional[Node[Relation[Any, MappedGraphQLDTOT], None]]=None, raise_if_no_fields: bool=False, tags: Optional[set[str]]=None, backend_kwargs: Optional[dict[str, Any]]=None, *, child_options: Optional[_ChildOptions]=None, aggregations: bool=True, description: Optional[str]=None, directives: Optional[Sequence[object]]=(), override: bool=False, user_defined: bool=False, register_type: bool=True, **kwargs: Any) -> type[MappedGraphQLDTOT]:
dto = super().factory(model, dto_config, base, name, parent_field_def, current_node, raise_if_no_fields, tags, backend_kwargs, aggregations=aggregations if dto_config.purpose is Purpose.READ else False, register_type=False, override=override, child_options=child_options, **kwargs)
child_options = child_options or _ChildOptions()
if self.graphql_type(dto_config) == 'object':
dto = self._update_fields(dto, base, pagination=child_options.pagination, order_by=child_options.order_by)
if register_type:
return self._register_type(dto, dto_config=dto_config, description=description, directives=directives, override=override, user_defined=user_defined, child_options=child_options, current_node=current_node)
return dto
|
class TypeDTOFactory(StrawchemyMappedFactory[MappedGraphQLDTOT]):
def __init__(self, mapper: Strawchemy, backend: DTOBackend[MappedGraphQLDTOT], handle_cycles: bool=True, type_map: Optional[dict[Any, Any]]=None, aggregation_factory: Optional[AggregateDTOFactory[AggregateDTOT]]=None, order_by_factory: Optional[OrderByDTOFactory]=None, **kwargs: Any) -> None:
pass
def _aggregation_field(self, field_def: DTOFieldDefinition[DeclarativeBase, QueryableAttribute[Any]], dto_config: DTOConfig) -> GraphQLFieldDefinition:
pass
def _update_fields(self, dto: type[GraphQLDTOT], base: Optional[type[Any]], pagination: Union[bool, DefaultOffsetPagination]=False, order_by: bool=False) -> type[GraphQLDTOT]:
pass
@override
def _cache_key(self, model: type[Any], dto_config: DTOConfig, node: Node[Relation[Any, MappedGraphQLDTOT], None], *, child_options: _ChildOptions, **factory_kwargs: Any) -> Hashable:
pass
@override
def dto_name(self, base_name: str, dto_config: DTOConfig, node: Optional[Node[Relation[Any, MappedGraphQLDTOT], None]]=None) -> str:
pass
@override
def iter_field_definitions(self, name: str, model: type[DeclarativeT], dto_config: DTOConfig, base: Optional[type[DTOBase[DeclarativeBase]]], node: Node[Relation[DeclarativeBase, MappedGraphQLDTOT], None], raise_if_no_fields: bool=False, *, aggregations: bool=False, field_map: Optional[dict[DTOKey, GraphQLFieldDefinition]]=None, **kwargs: Any) -> Generator[DTOFieldDefinition[DeclarativeBase, QueryableAttribute[Any]], None, None]:
pass
@override
def factory(self, model: type[DeclarativeT], dto_config: DTOConfig, base: Optional[type[Any]]=None, name: Optional[str]=None, parent_field_def: Optional[DTOFieldDefinition[DeclarativeBase, QueryableAttribute[Any]]]=None, current_node: Optional[Node[Relation[Any, MappedGraphQLDTOT], None]]=None, raise_if_no_fields: bool=False, tags: Optional[set[str]]=None, backend_kwargs: Optional[dict[str, Any]]=None, *, child_options: Optional[_ChildOptions]=None, aggregations: bool=True, description: Optional[str]=None, directives: Optional[Sequence[object]]=(), override:
pass
| 12
| 0
| 24
| 0
| 23
| 0
| 3
| 0
| 1
| 27
| 16
| 2
| 7
| 2
| 7
| 41
| 178
| 9
| 169
| 87
| 99
| 0
| 57
| 25
| 49
| 11
| 4
| 3
| 24
|
328,049
|
gazorby/strawchemy
|
/Users/umroot/Documents/PhD_works/PhD-Core-Contents/Class-level-dataset-curation/unseen_data/git_repos_for_analysis/gazorby_strawchemy/src/strawchemy/strawberry/factories/types.py
|
strawchemy.strawberry.factories.types.UpsertConflictFieldsDTOFactory
|
from strawchemy.strawberry.dto import AggregateDTO, AggregateFieldDefinition, DTOKey, EnumDTO, FunctionFieldDefinition, GraphQLFieldDefinition, MappedStrawberryGraphQLDTO
from strawchemy.dto.types import DTOConfig, DTOMissing, Purpose
from .enum import EnumDTOFactory, UpsertConflictFieldsEnumDTOBackend
from typing import TYPE_CHECKING, Any, Optional, TypeVar, Union
from typing_extensions import Self, override
from sqlalchemy.orm import DeclarativeBase, QueryableAttribute
from strawchemy.graph import Node
class UpsertConflictFieldsDTOFactory(EnumDTOFactory):
inspector: SQLAlchemyGraphQLInspector
def __init__(self, inspector: SQLAlchemyGraphQLInspector, backend: Optional[UpsertConflictFieldsEnumDTOBackend]=None, handle_cycles: bool=True, type_map: Optional[dict[Any, Any]]=None) -> None:
super().__init__(inspector, backend or UpsertConflictFieldsEnumDTOBackend(inspector), handle_cycles, type_map)
@override
def dto_name(self, base_name: str, dto_config: DTOConfig, node: Optional[Node[Relation[Any, EnumDTO], None]]=None) -> str:
return f'{base_name}ConflictFields'
@override
def should_exclude_field(self, field: DTOFieldDefinition[DeclarativeBase, QueryableAttribute[Any]], dto_config: DTOConfig, node: Node[Relation[Any, EnumDTO], None], has_override: bool) -> bool:
constraint_columns = {column for constraint in self.inspector.unique_constraints(field.model) for column in constraint.columns}
columns = field.model.__mapper__.column_attrs
return super().should_exclude_field(field, dto_config, node, has_override) or field.model_field_name not in columns or any((column not in constraint_columns for column in columns[field.model_field_name].columns))
|
class UpsertConflictFieldsDTOFactory(EnumDTOFactory):
def __init__(self, inspector: SQLAlchemyGraphQLInspector, backend: Optional[UpsertConflictFieldsEnumDTOBackend]=None, handle_cycles: bool=True, type_map: Optional[dict[Any, Any]]=None) -> None:
pass
@override
def dto_name(self, base_name: str, dto_config: DTOConfig, node: Optional[Node[Relation[Any, EnumDTO], None]]=None) -> str:
pass
@override
def should_exclude_field(self, field: DTOFieldDefinition[DeclarativeBase, QueryableAttribute[Any]], dto_config: DTOConfig, node: Node[Relation[Any, EnumDTO], None], has_override: bool) -> bool:
pass
| 6
| 0
| 9
| 0
| 9
| 0
| 1
| 0
| 1
| 12
| 7
| 0
| 3
| 0
| 3
| 25
| 35
| 3
| 32
| 23
| 12
| 0
| 10
| 6
| 6
| 1
| 3
| 0
| 3
|
328,050
|
gazorby/strawchemy
|
/Users/umroot/Documents/PhD_works/PhD-Core-Contents/Class-level-dataset-curation/unseen_data/git_repos_for_analysis/gazorby_strawchemy/src/strawchemy/strawberry/filters/base.py
|
strawchemy.strawberry.filters.base.ArrayFilter
|
from typing_extensions import override
from sqlalchemy.dialects import postgresql as pg
from dataclasses import dataclass
from strawberry import UNSET
from typing import TYPE_CHECKING, Any, ClassVar, Protocol, Union, cast
from sqlalchemy import cast as sqla_cast
from sqlalchemy import ARRAY, JSON, ColumnElement, Dialect, Integer, Text, and_, func, not_, null, or_, type_coerce
@dataclass(frozen=True)
class ArrayFilter(EqualityFilter):
comparison: ArrayComparison[Any]
@override
def to_expressions(self, dialect: Dialect, model_attribute: Union[ColumnElement[ARRAY[Any]], QueryableAttribute[ARRAY[Any]]]) -> list[ColumnElement[bool]]:
expressions: list[ColumnElement[bool]] = super().to_expressions(dialect, model_attribute)
as_postgres_array = type_coerce(model_attribute, pg.ARRAY(cast('ARRAY[Any]', model_attribute.type).item_type))
if self.comparison.contains is not UNSET:
expressions.append(as_postgres_array.contains(self.comparison.contains))
if self.comparison.contained_in is not UNSET:
expressions.append(as_postgres_array.contained_by(self.comparison.contained_in))
if self.comparison.overlap is not UNSET:
expressions.append(as_postgres_array.overlap(self.comparison.overlap))
return expressions
|
@dataclass(frozen=True)
class ArrayFilter(EqualityFilter):
@override
def to_expressions(self, dialect: Dialect, model_attribute: Union[ColumnElement[ARRAY[Any]], QueryableAttribute[ARRAY[Any]]]) -> list[ColumnElement[bool]]:
pass
| 4
| 0
| 13
| 1
| 12
| 0
| 4
| 0
| 1
| 4
| 0
| 0
| 1
| 0
| 1
| 27
| 17
| 2
| 15
| 7
| 10
| 0
| 12
| 4
| 10
| 4
| 7
| 1
| 4
|
328,051
|
gazorby/strawchemy
|
/Users/umroot/Documents/PhD_works/PhD-Core-Contents/Class-level-dataset-curation/unseen_data/git_repos_for_analysis/gazorby_strawchemy/src/strawchemy/strawberry/filters/base.py
|
strawchemy.strawberry.filters.base.BaseDateFilter
|
from strawberry import UNSET
from typing_extensions import override
from dataclasses import dataclass
from sqlalchemy import ARRAY, JSON, ColumnElement, Dialect, Integer, Text, and_, func, not_, null, or_, type_coerce
from typing import TYPE_CHECKING, Any, ClassVar, Protocol, Union, cast
from sqlalchemy import cast as sqla_cast
@dataclass(frozen=True)
class BaseDateFilter(FilterProtocol):
comparison: Union[DateComparison, DateTimeComparison]
def _sqlite_date(self, dialect: Dialect, model_attribute: Union[ColumnElement[date], QueryableAttribute[date]]) -> list[ColumnElement[bool]]:
expressions: list[ColumnElement[bool]] = []
if self.comparison.year is not UNSET and self.comparison.year:
expressions.extend(self.comparison.year.to_expressions(dialect, sqla_cast(func.strftime('%Y', model_attribute), Integer)))
if self.comparison.month is not UNSET and self.comparison.month:
expressions.extend(self.comparison.month.to_expressions(dialect, sqla_cast(func.strftime('%m', model_attribute), Integer)))
if self.comparison.day is not UNSET and self.comparison.day:
expressions.extend(self.comparison.day.to_expressions(dialect, sqla_cast(func.strftime('%e', model_attribute), Integer)))
if self.comparison.week is not UNSET and self.comparison.week:
expressions.extend(self.comparison.week.to_expressions(dialect, sqla_cast(func.strftime('%V', model_attribute), Integer)))
if self.comparison.week_day is not UNSET and self.comparison.week_day:
expressions.extend(self.comparison.week_day.to_expressions(dialect, sqla_cast(func.strftime('%w', model_attribute), Integer)))
if self.comparison.quarter is not UNSET and self.comparison.quarter:
expressions.extend(self.comparison.quarter.to_expressions(dialect, sqla_cast((sqla_cast(func.strftime('%m', model_attribute), Integer) + 2) / 3, Integer)))
if self.comparison.iso_week_day is not UNSET and self.comparison.iso_week_day:
expressions.extend(self.comparison.iso_week_day.to_expressions(dialect, sqla_cast(func.strftime('%u', model_attribute), Integer)))
if self.comparison.iso_year is not UNSET and self.comparison.iso_year:
expressions.extend(self.comparison.iso_year.to_expressions(dialect, sqla_cast(func.strftime('%G', model_attribute), Integer)))
return expressions
def _postgres_date(self, dialect: Dialect, model_attribute: Union[ColumnElement[date], QueryableAttribute[date]]) -> list[ColumnElement[bool]]:
expressions: list[ColumnElement[bool]] = []
if self.comparison.year is not UNSET and self.comparison.year:
expressions.extend(self.comparison.year.to_expressions(dialect, func.extract('YEAR', model_attribute)))
if self.comparison.month is not UNSET and self.comparison.month:
expressions.extend(self.comparison.month.to_expressions(dialect, func.extract('MONTH', model_attribute)))
if self.comparison.day is not UNSET and self.comparison.day:
expressions.extend(self.comparison.day.to_expressions(dialect, func.extract('DAY', model_attribute)))
if self.comparison.week is not UNSET and self.comparison.week:
expressions.extend(self.comparison.week.to_expressions(dialect, func.extract('WEEK', model_attribute)))
if self.comparison.week_day is not UNSET and self.comparison.week_day:
expressions.extend(self.comparison.week_day.to_expressions(dialect, func.extract('DOW', model_attribute)))
if self.comparison.quarter is not UNSET and self.comparison.quarter:
expressions.extend(self.comparison.quarter.to_expressions(dialect, func.extract('QUARTER', model_attribute)))
if self.comparison.iso_week_day is not UNSET and self.comparison.iso_week_day:
expressions.extend(self.comparison.iso_week_day.to_expressions(dialect, func.extract('ISODOW', model_attribute)))
if self.comparison.iso_year is not UNSET and self.comparison.iso_year:
expressions.extend(self.comparison.iso_year.to_expressions(dialect, func.extract('ISOYEAR', model_attribute)))
return expressions
def _mysql_date(self, dialect: Dialect, model_attribute: Union[ColumnElement[date], QueryableAttribute[date]]) -> list[ColumnElement[bool]]:
expressions: list[ColumnElement[bool]] = []
if self.comparison.year is not UNSET and self.comparison.year:
expressions.extend(self.comparison.year.to_expressions(dialect, func.extract('YEAR', model_attribute)))
if self.comparison.month is not UNSET and self.comparison.month:
expressions.extend(self.comparison.month.to_expressions(dialect, func.extract('MONTH', model_attribute)))
if self.comparison.day is not UNSET and self.comparison.day:
expressions.extend(self.comparison.day.to_expressions(dialect, func.extract('DAY', model_attribute)))
if self.comparison.week is not UNSET and self.comparison.week:
expressions.extend(self.comparison.week.to_expressions(dialect, func.week(model_attribute, 3)))
if self.comparison.week_day is not UNSET and self.comparison.week_day:
expressions.extend(self.comparison.week_day.to_expressions(dialect, func.date_format(model_attribute, '%w')))
if self.comparison.quarter is not UNSET and self.comparison.quarter:
expressions.extend(self.comparison.quarter.to_expressions(dialect, func.extract('QUARTER', model_attribute)))
if self.comparison.iso_week_day is not UNSET and self.comparison.iso_week_day:
expressions.extend(self.comparison.iso_week_day.to_expressions(dialect, func.weekday(model_attribute) + 1))
if self.comparison.iso_year is not UNSET and self.comparison.iso_year:
expressions.extend(self.comparison.iso_year.to_expressions(dialect, func.date_format(model_attribute, '%x')))
return expressions
@override
def to_expressions(self, dialect: Dialect, model_attribute: Union[ColumnElement[Any], QueryableAttribute[Any]]) -> list[ColumnElement[bool]]:
expressions = super().to_expressions(dialect, model_attribute)
if dialect.name == 'postgresql':
expressions.extend(self._postgres_date(dialect, model_attribute))
elif dialect.name == 'mysql':
expressions.extend(self._mysql_date(dialect, model_attribute))
elif dialect.name == 'sqlite':
expressions.extend(self._sqlite_date(dialect, model_attribute))
return expressions
|
@dataclass(frozen=True)
class BaseDateFilter(FilterProtocol):
def _sqlite_date(self, dialect: Dialect, model_attribute: Union[ColumnElement[date], QueryableAttribute[date]]) -> list[ColumnElement[bool]]:
pass
def _postgres_date(self, dialect: Dialect, model_attribute: Union[ColumnElement[date], QueryableAttribute[date]]) -> list[ColumnElement[bool]]:
pass
def _mysql_date(self, dialect: Dialect, model_attribute: Union[ColumnElement[date], QueryableAttribute[date]]) -> list[ColumnElement[bool]]:
pass
@override
def to_expressions(self, dialect: Dialect, model_attribute: Union[ColumnElement[Any], QueryableAttribute[Any]]) -> list[ColumnElement[bool]]:
pass
| 7
| 0
| 30
| 2
| 28
| 0
| 8
| 0
| 1
| 5
| 0
| 2
| 4
| 0
| 4
| 29
| 125
| 11
| 114
| 18
| 100
| 0
| 66
| 9
| 61
| 9
| 6
| 1
| 31
|
328,052
|
gazorby/strawchemy
|
/Users/umroot/Documents/PhD_works/PhD-Core-Contents/Class-level-dataset-curation/unseen_data/git_repos_for_analysis/gazorby_strawchemy/src/strawchemy/strawberry/filters/base.py
|
strawchemy.strawberry.filters.base.BaseTimeFilter
|
from sqlalchemy import ARRAY, JSON, ColumnElement, Dialect, Integer, Text, and_, func, not_, null, or_, type_coerce
from dataclasses import dataclass
from typing import TYPE_CHECKING, Any, ClassVar, Protocol, Union, cast
from sqlalchemy import cast as sqla_cast
from typing_extensions import override
@dataclass(frozen=True)
class BaseTimeFilter(FilterProtocol):
comparison: Union[TimeComparison, DateTimeComparison]
def _sqlite_time(self, dialect: Dialect, model_attribute: Union[ColumnElement[date], QueryableAttribute[date]]) -> list[ColumnElement[bool]]:
expressions: list[ColumnElement[bool]] = []
if self.comparison.hour:
expressions.extend(self.comparison.hour.to_expressions(dialect, sqla_cast(func.strftime('%H', model_attribute), Integer)))
if self.comparison.minute:
expressions.extend(self.comparison.minute.to_expressions(dialect, sqla_cast(func.strftime('%M', model_attribute), Integer)))
if self.comparison.second:
expressions.extend(self.comparison.second.to_expressions(dialect, sqla_cast(func.strftime('%S', model_attribute), Integer)))
return expressions
def _extract_time(self, dialect: Dialect, model_attribute: Union[ColumnElement[date], QueryableAttribute[date]]) -> list[ColumnElement[bool]]:
expressions: list[ColumnElement[bool]] = []
if self.comparison.hour:
expressions.extend(self.comparison.hour.to_expressions(dialect, func.extract('HOUR', model_attribute)))
if self.comparison.minute:
expressions.extend(self.comparison.minute.to_expressions(dialect, func.extract('MINUTE', model_attribute)))
if self.comparison.second:
expressions.extend(self.comparison.second.to_expressions(dialect, func.extract('SECOND', model_attribute)))
return expressions
@override
def to_expressions(self, dialect: Dialect, model_attribute: Union[ColumnElement[Any], QueryableAttribute[Any]]) -> list[ColumnElement[bool]]:
expressions = super().to_expressions(dialect, model_attribute)
if dialect.name == 'sqlite':
expressions.extend(self._sqlite_time(dialect, model_attribute))
else:
expressions.extend(self._extract_time(dialect, model_attribute))
return expressions
|
@dataclass(frozen=True)
class BaseTimeFilter(FilterProtocol):
def _sqlite_time(self, dialect: Dialect, model_attribute: Union[ColumnElement[date], QueryableAttribute[date]]) -> list[ColumnElement[bool]]:
pass
def _extract_time(self, dialect: Dialect, model_attribute: Union[ColumnElement[date], QueryableAttribute[date]]) -> list[ColumnElement[bool]]:
pass
@override
def to_expressions(self, dialect: Dialect, model_attribute: Union[ColumnElement[Any], QueryableAttribute[Any]]) -> list[ColumnElement[bool]]:
pass
| 6
| 0
| 14
| 2
| 12
| 0
| 3
| 0
| 1
| 5
| 0
| 2
| 3
| 0
| 3
| 28
| 49
| 9
| 40
| 14
| 29
| 0
| 26
| 7
| 22
| 4
| 6
| 1
| 10
|
328,053
|
gazorby/strawchemy
|
/Users/umroot/Documents/PhD_works/PhD-Core-Contents/Class-level-dataset-curation/unseen_data/git_repos_for_analysis/gazorby_strawchemy/src/strawchemy/strawberry/filters/base.py
|
strawchemy.strawberry.filters.base.DateFilter
|
from dataclasses import dataclass
@dataclass(frozen=True)
class DateFilter(BaseDateFilter, OrderFilter):
comparison: DateComparison
|
@dataclass(frozen=True)
class DateFilter(BaseDateFilter, OrderFilter):
pass
| 2
| 0
| 0
| 0
| 0
| 0
| 0
| 0
| 2
| 0
| 0
| 0
| 0
| 0
| 0
| 31
| 2
| 0
| 2
| 1
| 1
| 0
| 2
| 1
| 1
| 0
| 8
| 0
| 0
|
328,054
|
gazorby/strawchemy
|
/Users/umroot/Documents/PhD_works/PhD-Core-Contents/Class-level-dataset-curation/unseen_data/git_repos_for_analysis/gazorby_strawchemy/src/strawchemy/strawberry/filters/base.py
|
strawchemy.strawberry.filters.base.DateTimeFilter
|
from dataclasses import dataclass
@dataclass(frozen=True)
class DateTimeFilter(BaseDateFilter, BaseTimeFilter, OrderFilter):
comparison: DateTimeComparison
|
@dataclass(frozen=True)
class DateTimeFilter(BaseDateFilter, BaseTimeFilter, OrderFilter):
pass
| 2
| 0
| 0
| 0
| 0
| 0
| 0
| 0
| 3
| 0
| 0
| 0
| 0
| 0
| 0
| 34
| 2
| 0
| 2
| 1
| 1
| 0
| 2
| 1
| 1
| 0
| 8
| 0
| 0
|
328,055
|
gazorby/strawchemy
|
/Users/umroot/Documents/PhD_works/PhD-Core-Contents/Class-level-dataset-curation/unseen_data/git_repos_for_analysis/gazorby_strawchemy/src/strawchemy/strawberry/filters/base.py
|
strawchemy.strawberry.filters.base.EqualityFilter
|
from strawberry import UNSET
from sqlalchemy import ARRAY, JSON, ColumnElement, Dialect, Integer, Text, and_, func, not_, null, or_, type_coerce
from dataclasses import dataclass
from typing_extensions import override
from typing import TYPE_CHECKING, Any, ClassVar, Protocol, Union, cast
@dataclass(frozen=True)
class EqualityFilter(FilterProtocol):
comparison: EqualityComparison[Any]
@override
def to_expressions(self, dialect: Dialect, model_attribute: Union[QueryableAttribute[Any], ColumnElement[Any]]) -> list[ColumnElement[bool]]:
expressions: list[ColumnElement[bool]] = []
if self.comparison.eq is not UNSET:
expressions.append(model_attribute == self.comparison.eq)
if self.comparison.neq is not UNSET:
expressions.append(model_attribute != self.comparison.neq)
if self.comparison.in_ is not UNSET and self.comparison.in_:
expressions.append(model_attribute.in_(self.comparison.in_))
if self.comparison.nin is not UNSET and self.comparison.nin:
expressions.append(model_attribute.not_in(self.comparison.nin))
if self.comparison.is_null is not UNSET:
expressions.append(model_attribute.is_(null()) if self.comparison.is_null else model_attribute.is_not(null()))
return expressions
|
@dataclass(frozen=True)
class EqualityFilter(FilterProtocol):
@override
def to_expressions(self, dialect: Dialect, model_attribute: Union[QueryableAttribute[Any], ColumnElement[Any]]) -> list[ColumnElement[bool]]:
pass
| 4
| 0
| 21
| 2
| 19
| 0
| 7
| 0
| 1
| 3
| 0
| 3
| 1
| 0
| 1
| 26
| 25
| 3
| 22
| 8
| 15
| 0
| 15
| 3
| 13
| 7
| 6
| 1
| 7
|
328,056
|
gazorby/strawchemy
|
/Users/umroot/Documents/PhD_works/PhD-Core-Contents/Class-level-dataset-curation/unseen_data/git_repos_for_analysis/gazorby_strawchemy/src/strawchemy/strawberry/filters/base.py
|
strawchemy.strawberry.filters.base.FilterProtocol
|
from dataclasses import dataclass
from typing import TYPE_CHECKING, Any, ClassVar, Protocol, Union, cast
from sqlalchemy import ARRAY, JSON, ColumnElement, Dialect, Integer, Text, and_, func, not_, null, or_, type_coerce
@dataclass(frozen=True)
class FilterProtocol(Protocol):
comparison: GraphQLComparison
def to_expressions(self, dialect: Dialect, model_attribute: Union[QueryableAttribute[Any], ColumnElement[Any]]) -> list[ColumnElement[bool]]:
return []
|
@dataclass(frozen=True)
class FilterProtocol(Protocol):
def to_expressions(self, dialect: Dialect, model_attribute: Union[QueryableAttribute[Any], ColumnElement[Any]]) -> list[ColumnElement[bool]]:
pass
| 3
| 0
| 4
| 0
| 4
| 0
| 1
| 0
| 1
| 3
| 0
| 4
| 1
| 0
| 1
| 25
| 7
| 1
| 6
| 4
| 2
| 0
| 4
| 2
| 2
| 1
| 5
| 0
| 1
|
328,057
|
gazorby/strawchemy
|
/Users/umroot/Documents/PhD_works/PhD-Core-Contents/Class-level-dataset-curation/unseen_data/git_repos_for_analysis/gazorby_strawchemy/src/strawchemy/strawberry/filters/base.py
|
strawchemy.strawberry.filters.base.JSONFilter
|
from sqlalchemy import ARRAY, JSON, ColumnElement, Dialect, Integer, Text, and_, func, not_, null, or_, type_coerce
from typing_extensions import override
from sqlalchemy.dialects import postgresql as pg
from typing import TYPE_CHECKING, Any, ClassVar, Protocol, Union, cast
from sqlalchemy.dialects import mysql
from sqlalchemy import cast as sqla_cast
from dataclasses import dataclass
from strawberry import UNSET
@dataclass(frozen=True)
class JSONFilter(EqualityFilter):
comparison: _JSONComparison
def _postgres_json(self, model_attribute: Union[ColumnElement[JSON], QueryableAttribute[JSON]]) -> list[ColumnElement[bool]]:
expressions: list[ColumnElement[bool]] = []
as_postgres_jsonb = type_coerce(model_attribute, pg.JSONB)
if self.comparison.contains is not UNSET:
expressions.append(as_postgres_jsonb.contains(self.comparison.contains))
if self.comparison.contained_in is not UNSET:
expressions.append(as_postgres_jsonb.contained_by(self.comparison.contained_in))
if self.comparison.has_key is not UNSET:
expressions.append(as_postgres_jsonb.has_key(self.comparison.has_key))
if self.comparison.has_key_all is not UNSET:
expressions.append(as_postgres_jsonb.has_all(sqla_cast(self.comparison.has_key_all, pg.ARRAY(Text))))
if self.comparison.has_key_any is not UNSET:
expressions.append(as_postgres_jsonb.has_any(sqla_cast(self.comparison.has_key_any, pg.ARRAY(Text))))
return expressions
def _mysql_json(self, model_attribute: Union[ColumnElement[JSON], QueryableAttribute[JSON]]) -> list[ColumnElement[bool]]:
expressions: list[ColumnElement[bool]] = []
as_mysql_json = type_coerce(model_attribute, mysql.JSON)
if self.comparison.contains is not UNSET:
expressions.append(func.json_contains(as_mysql_json, sqla_cast(self.comparison.contains, mysql.JSON)))
if self.comparison.contained_in is not UNSET:
expressions.append(func.json_contains(sqla_cast(self.comparison.contained_in, mysql.JSON), as_mysql_json))
if self.comparison.has_key is not UNSET:
expressions.append(func.json_contains_path(as_mysql_json, 'all', f'$.{self.comparison.has_key}'))
if self.comparison.has_key_all is not UNSET and self.comparison.has_key_all:
expressions.append(func.json_contains_path(as_mysql_json, 'all', *[f'$.{key}' for key in self.comparison.has_key_all]))
if self.comparison.has_key_any is not UNSET and self.comparison.has_key_any:
expressions.append(func.json_contains_path(as_mysql_json, 'one', *[f'$.{key}' for key in self.comparison.has_key_any]))
return expressions
def _sqlite_json(self, model_attribute: Union[ColumnElement[JSON], QueryableAttribute[JSON]]) -> list[ColumnElement[bool]]:
expressions: list[ColumnElement[bool]] = []
if self.comparison.has_key is not UNSET:
expressions.append(func.json_extract(model_attribute, f'$.{self.comparison.has_key}').is_not(null()))
if self.comparison.has_key_all is not UNSET and self.comparison.has_key_all:
expressions.append(and_(*[func.json_extract(model_attribute, f'$.{key}').is_not(null()) for key in self.comparison.has_key_all]))
if self.comparison.has_key_any is not UNSET and self.comparison.has_key_any:
expressions.append(or_(*[func.json_extract(model_attribute, f'$.{key}').is_not(null()) for key in self.comparison.has_key_any]))
return expressions
@override
def to_expressions(self, dialect: Dialect, model_attribute: Union[QueryableAttribute[JSON], ColumnElement[JSON]]) -> list[ColumnElement[bool]]:
expressions: list[ColumnElement[bool]] = super().to_expressions(dialect, model_attribute)
if dialect.name == 'postgresql':
expressions.extend(self._postgres_json(model_attribute))
elif dialect.name == 'mysql':
expressions.extend(self._mysql_json(model_attribute))
elif dialect.name == 'sqlite':
expressions.extend(self._sqlite_json(model_attribute))
return expressions
|
@dataclass(frozen=True)
class JSONFilter(EqualityFilter):
def _postgres_json(self, model_attribute: Union[ColumnElement[JSON], QueryableAttribute[JSON]]) -> list[ColumnElement[bool]]:
pass
def _mysql_json(self, model_attribute: Union[ColumnElement[JSON], QueryableAttribute[JSON]]) -> list[ColumnElement[bool]]:
pass
def _sqlite_json(self, model_attribute: Union[ColumnElement[JSON], QueryableAttribute[JSON]]) -> list[ColumnElement[bool]]:
pass
@override
def to_expressions(self, dialect: Dialect, model_attribute: Union[QueryableAttribute[JSON], ColumnElement[JSON]]) -> list[ColumnElement[bool]]:
pass
| 7
| 0
| 19
| 1
| 18
| 0
| 5
| 0
| 1
| 3
| 0
| 0
| 4
| 0
| 4
| 30
| 84
| 9
| 75
| 20
| 61
| 0
| 46
| 11
| 41
| 6
| 7
| 1
| 20
|
328,058
|
gazorby/strawchemy
|
/Users/umroot/Documents/PhD_works/PhD-Core-Contents/Class-level-dataset-curation/unseen_data/git_repos_for_analysis/gazorby_strawchemy/src/strawchemy/strawberry/filters/base.py
|
strawchemy.strawberry.filters.base.OrderFilter
|
from typing import TYPE_CHECKING, Any, ClassVar, Protocol, Union, cast
from sqlalchemy import ARRAY, JSON, ColumnElement, Dialect, Integer, Text, and_, func, not_, null, or_, type_coerce
from dataclasses import dataclass
from typing_extensions import override
from strawberry import UNSET
@dataclass(frozen=True)
class OrderFilter(EqualityFilter):
comparison: OrderComparison[Any]
@override
def to_expressions(self, dialect: Dialect, model_attribute: Union[QueryableAttribute[Any], ColumnElement[Any]]) -> list[ColumnElement[bool]]:
expressions: list[ColumnElement[bool]] = super().to_expressions(dialect, model_attribute)
if self.comparison.gt is not UNSET:
expressions.append(model_attribute > self.comparison.gt)
if self.comparison.gte is not UNSET:
expressions.append(model_attribute >= self.comparison.gte)
if self.comparison.lt is not UNSET:
expressions.append(model_attribute < self.comparison.lt)
if self.comparison.lte is not UNSET:
expressions.append(model_attribute <= self.comparison.lte)
return expressions
|
@dataclass(frozen=True)
class OrderFilter(EqualityFilter):
@override
def to_expressions(self, dialect: Dialect, model_attribute: Union[QueryableAttribute[Any], ColumnElement[Any]]) -> list[ColumnElement[bool]]:
pass
| 4
| 0
| 15
| 2
| 13
| 0
| 5
| 0
| 1
| 4
| 0
| 5
| 1
| 0
| 1
| 27
| 19
| 3
| 16
| 6
| 11
| 0
| 13
| 3
| 11
| 5
| 7
| 1
| 5
|
328,059
|
gazorby/strawchemy
|
/Users/umroot/Documents/PhD_works/PhD-Core-Contents/Class-level-dataset-curation/unseen_data/git_repos_for_analysis/gazorby_strawchemy/src/strawchemy/strawberry/filters/base.py
|
strawchemy.strawberry.filters.base.TextFilter
|
from sqlalchemy import ARRAY, JSON, ColumnElement, Dialect, Integer, Text, and_, func, not_, null, or_, type_coerce
from dataclasses import dataclass
from typing_extensions import override
from strawberry import UNSET
from typing import TYPE_CHECKING, Any, ClassVar, Protocol, Union, cast
@dataclass(frozen=True)
class TextFilter(OrderFilter):
comparison: TextComparison
def _like_expressions(self, model_attribute: Union[QueryableAttribute[str], ColumnElement[str]]) -> list[ColumnElement[bool]]:
expressions: list[ColumnElement[bool]] = []
if self.comparison.like is not UNSET:
expressions.append(model_attribute.like(self.comparison.like))
if self.comparison.nlike is not UNSET:
expressions.append(model_attribute.not_like(self.comparison.nlike))
if self.comparison.ilike is not UNSET:
expressions.append(model_attribute.ilike(self.comparison.ilike))
if self.comparison.nilike is not UNSET:
expressions.append(model_attribute.not_ilike(self.comparison.nilike))
return expressions
def _regexp_expressions(self, dialect: Dialect, model_attribute: Union[QueryableAttribute[str], ColumnElement[str]]) -> list[ColumnElement[bool]]:
expressions: list[ColumnElement[bool]] = []
if self.comparison.regexp is not UNSET or self.comparison.nregexp is not UNSET:
regex = self.comparison.regexp or self.comparison.nregexp
if dialect.name == 'mysql':
regex_comp = func.regexp_like(model_attribute, regex, 'c')
else:
regex_comp = model_attribute.regexp_match(regex)
if self.comparison.regexp is not UNSET:
expressions.append(regex_comp)
else:
expressions.append(not_(regex_comp))
if self.comparison.iregexp is not UNSET:
expressions.append(func.lower(model_attribute).regexp_match(self.comparison.iregexp))
if self.comparison.inregexp is not UNSET:
expressions.append(not_(func.lower(model_attribute).regexp_match(self.comparison.inregexp)))
return expressions
@override
def to_expressions(self, dialect: Dialect, model_attribute: Union[QueryableAttribute[str], ColumnElement[str]]) -> list[ColumnElement[bool]]:
expressions: list[ColumnElement[bool]] = super().to_expressions(dialect, model_attribute)
expressions.extend(self._like_expressions(model_attribute))
expressions.extend(self._regexp_expressions(dialect, model_attribute))
if self.comparison.startswith is not UNSET:
expressions.append(model_attribute.startswith(self.comparison.startswith, autoescape=True))
if self.comparison.endswith is not UNSET:
expressions.append(model_attribute.endswith(self.comparison.endswith, autoescape=True))
if self.comparison.contains is not UNSET:
expressions.append(model_attribute.contains(self.comparison.contains, autoescape=True))
if self.comparison.istartswith is not UNSET:
expressions.append(model_attribute.istartswith(self.comparison.istartswith, autoescape=True))
if self.comparison.iendswith is not UNSET:
expressions.append(model_attribute.iendswith(self.comparison.iendswith, autoescape=True))
if self.comparison.icontains is not UNSET:
expressions.append(model_attribute.icontains(self.comparison.icontains, autoescape=True))
return expressions
|
@dataclass(frozen=True)
class TextFilter(OrderFilter):
def _like_expressions(self, model_attribute: Union[QueryableAttribute[str], ColumnElement[str]]) -> list[ColumnElement[bool]]:
pass
def _regexp_expressions(self, dialect: Dialect, model_attribute: Union[QueryableAttribute[str], ColumnElement[str]]) -> list[ColumnElement[bool]]:
pass
@override
def to_expressions(self, dialect: Dialect, model_attribute: Union[QueryableAttribute[str], ColumnElement[str]]) -> list[ColumnElement[bool]]:
pass
| 6
| 0
| 19
| 2
| 18
| 0
| 6
| 0
| 1
| 4
| 0
| 0
| 3
| 0
| 3
| 30
| 64
| 8
| 56
| 18
| 43
| 0
| 45
| 9
| 41
| 7
| 8
| 2
| 18
|
328,060
|
gazorby/strawchemy
|
/Users/umroot/Documents/PhD_works/PhD-Core-Contents/Class-level-dataset-curation/unseen_data/git_repos_for_analysis/gazorby_strawchemy/src/strawchemy/strawberry/filters/base.py
|
strawchemy.strawberry.filters.base.TimeDeltaFilter
|
from typing_extensions import override
from dataclasses import dataclass
from sqlalchemy import ARRAY, JSON, ColumnElement, Dialect, Integer, Text, and_, func, not_, null, or_, type_coerce
from typing import TYPE_CHECKING, Any, ClassVar, Protocol, Union, cast
from sqlalchemy import cast as sqla_cast
@dataclass(frozen=True)
class TimeDeltaFilter(OrderFilter):
comparison: TimeDeltaComparison
_seconds_in_day: ClassVar[int] = 60 * 60 * 24
def _postgres_interval(self, dialect: Dialect, model_attribute: Union[ColumnElement[timedelta], QueryableAttribute[timedelta]]) -> list[ColumnElement[bool]]:
expressions: list[ColumnElement[bool]] = []
if self.comparison.days:
expressions.extend(self.comparison.days.to_expressions(dialect, func.extract('EPOCH', model_attribute) / self._seconds_in_day))
if self.comparison.hours:
expressions.extend(self.comparison.hours.to_expressions(dialect, func.extract('EPOCH', model_attribute) / 3600))
if self.comparison.minutes:
expressions.extend(self.comparison.minutes.to_expressions(dialect, func.extract('EPOCH', model_attribute) / 60))
if self.comparison.seconds:
expressions.extend(self.comparison.seconds.to_expressions(dialect, func.extract('EPOCH', model_attribute)))
return expressions
def _mysql_interval(self, dialect: Dialect, model_attribute: Union[ColumnElement[timedelta], QueryableAttribute[timedelta]]) -> list[ColumnElement[bool]]:
expressions: list[ColumnElement[bool]] = []
if self.comparison.days:
expressions.extend(self.comparison.days.to_expressions(dialect, func.unix_timestamp(model_attribute) / self._seconds_in_day))
if self.comparison.hours:
expressions.extend(self.comparison.hours.to_expressions(dialect, func.unix_timestamp(model_attribute) / 3600))
if self.comparison.minutes:
expressions.extend(self.comparison.minutes.to_expressions(dialect, func.unix_timestamp(model_attribute) / 60))
if self.comparison.seconds:
expressions.extend(self.comparison.seconds.to_expressions(dialect, func.unix_timestamp(model_attribute)))
return expressions
def _sqlite_interval(self, dialect: Dialect, model_attribute: Union[ColumnElement[timedelta], QueryableAttribute[timedelta]]) -> list[ColumnElement[bool]]:
expressions: list[ColumnElement[bool]] = []
if self.comparison.days:
expressions.extend(self.comparison.days.to_expressions(dialect, sqla_cast(func.strftime('%s', model_attribute), Integer) / self._seconds_in_day))
if self.comparison.hours:
expressions.extend(self.comparison.hours.to_expressions(dialect, sqla_cast(func.strftime('%s', model_attribute), Integer) / 3600))
if self.comparison.minutes:
expressions.extend(self.comparison.minutes.to_expressions(dialect, sqla_cast(func.strftime('%s', model_attribute), Integer) / 60))
if self.comparison.seconds:
expressions.extend(self.comparison.seconds.to_expressions(dialect, sqla_cast(func.strftime('%s', model_attribute), Integer)))
return expressions
@override
def to_expressions(self, dialect: Dialect, model_attribute: Union[ColumnElement[timedelta], QueryableAttribute[timedelta]]) -> list[ColumnElement[bool]]:
expressions = super().to_expressions(dialect, model_attribute)
if dialect.name == 'postgresql':
expressions.extend(self._postgres_interval(dialect, model_attribute))
elif dialect.name == 'mysql':
expressions.extend(self._mysql_interval(dialect, model_attribute))
elif dialect.name == 'sqlite':
expressions.extend(self._sqlite_interval(dialect, model_attribute))
return expressions
|
@dataclass(frozen=True)
class TimeDeltaFilter(OrderFilter):
def _postgres_interval(self, dialect: Dialect, model_attribute: Union[ColumnElement[timedelta], QueryableAttribute[timedelta]]) -> list[ColumnElement[bool]]:
pass
def _mysql_interval(self, dialect: Dialect, model_attribute: Union[ColumnElement[timedelta], QueryableAttribute[timedelta]]) -> list[ColumnElement[bool]]:
pass
def _sqlite_interval(self, dialect: Dialect, model_attribute: Union[ColumnElement[timedelta], QueryableAttribute[timedelta]]) -> list[ColumnElement[bool]]:
pass
@override
def to_expressions(self, dialect: Dialect, model_attribute: Union[ColumnElement[timedelta], QueryableAttribute[timedelta]]) -> list[ColumnElement[bool]]:
pass
| 7
| 0
| 23
| 2
| 21
| 0
| 5
| 0
| 1
| 4
| 0
| 0
| 4
| 0
| 4
| 31
| 98
| 12
| 86
| 19
| 72
| 0
| 43
| 10
| 38
| 5
| 8
| 1
| 19
|
328,061
|
gazorby/strawchemy
|
/Users/umroot/Documents/PhD_works/PhD-Core-Contents/Class-level-dataset-curation/unseen_data/git_repos_for_analysis/gazorby_strawchemy/src/strawchemy/strawberry/filters/base.py
|
strawchemy.strawberry.filters.base.TimeFilter
|
from dataclasses import dataclass
@dataclass(frozen=True)
class TimeFilter(BaseTimeFilter, OrderFilter):
comparison: TimeComparison
|
@dataclass(frozen=True)
class TimeFilter(BaseTimeFilter, OrderFilter):
pass
| 2
| 0
| 0
| 0
| 0
| 0
| 0
| 0
| 2
| 0
| 0
| 0
| 0
| 0
| 0
| 30
| 2
| 0
| 2
| 1
| 1
| 0
| 2
| 1
| 1
| 0
| 8
| 0
| 0
|
328,062
|
gazorby/strawchemy
|
/Users/umroot/Documents/PhD_works/PhD-Core-Contents/Class-level-dataset-curation/unseen_data/git_repos_for_analysis/gazorby_strawchemy/src/strawchemy/strawberry/filters/geo.py
|
strawchemy.strawberry.filters.geo.GeoComparison
|
from strawberry import UNSET
import strawberry
from .inputs import GraphQLComparison
from strawchemy.strawberry.geo import GeoJSON
from typing import Any, Optional, TypeVar, Union
@strawberry.input
class GeoComparison(GraphQLComparison):
"""Geo comparison class for GraphQL filters.
This class provides a set of geospatial comparison operators that can be
used to filter data based on geometry containment.
Attributes:
contains_geometry: Filters for geometries that contain this geometry.
within_geometry: Filters for geometries that are within this geometry.
"""
__strawchemy_filter__ = GeoFilter
contains_geometry: Optional[GeoJSON] = UNSET
within_geometry: Optional[GeoJSON] = UNSET
is_null: Optional[bool] = UNSET
| null | 2
| 1
| 0
| 0
| 0
| 0
| 0
| 1.8
| 1
| 0
| 0
| 0
| 0
| 0
| 0
| 3
| 16
| 4
| 5
| 5
| 4
| 9
| 5
| 5
| 4
| 0
| 1
| 0
| 0
|
328,063
|
gazorby/strawchemy
|
/Users/umroot/Documents/PhD_works/PhD-Core-Contents/Class-level-dataset-curation/unseen_data/git_repos_for_analysis/gazorby_strawchemy/src/strawchemy/strawberry/filters/geo.py
|
strawchemy.strawberry.filters.geo.GeoFilter
|
from .base import FilterProtocol
from dataclasses import dataclass
from sqlalchemy.orm import QueryableAttribute
from typing_extensions import override
from sqlalchemy import ColumnElement, Dialect, null
from typing import Any, Optional, TypeVar, Union
from geoalchemy2 import functions as geo_func
@dataclass(frozen=True)
class GeoFilter(FilterProtocol):
comparison: GeoComparison
@override
def to_expressions(self, dialect: Dialect, model_attribute: Union[QueryableAttribute[Any], ColumnElement[Any]]) -> list[ColumnElement[bool]]:
expressions: list[ColumnElement[bool]] = []
if self.comparison.contains_geometry:
expressions.append(geo_func.ST_Contains(model_attribute, geo_func.ST_GeomFromGeoJSON(self.comparison.contains_geometry.geo.model_dump_json())))
if self.comparison.within_geometry:
expressions.append(geo_func.ST_Within(model_attribute, geo_func.ST_GeomFromGeoJSON(self.comparison.within_geometry.geo.model_dump_json())))
if self.comparison.is_null:
expressions.append(model_attribute.is_(null()) if self.comparison.is_null else model_attribute.is_not(null()))
return expressions
|
@dataclass(frozen=True)
class GeoFilter(FilterProtocol):
@override
def to_expressions(self, dialect: Dialect, model_attribute: Union[QueryableAttribute[Any], ColumnElement[Any]]) -> list[ColumnElement[bool]]:
pass
| 4
| 0
| 24
| 2
| 22
| 0
| 5
| 0
| 1
| 3
| 0
| 0
| 1
| 0
| 1
| 26
| 28
| 3
| 25
| 6
| 20
| 0
| 11
| 3
| 9
| 5
| 6
| 1
| 5
|
328,064
|
gazorby/strawchemy
|
/Users/umroot/Documents/PhD_works/PhD-Core-Contents/Class-level-dataset-curation/unseen_data/git_repos_for_analysis/gazorby_strawchemy/src/strawchemy/strawberry/filters/inputs.py
|
strawchemy.strawberry.filters.inputs.ArrayComparison
|
from typing import TYPE_CHECKING, Any, Generic, Optional, TypeVar, Union
from .base import ArrayFilter, DateFilter, DateTimeFilter, EqualityFilter, FilterProtocol, JSONFilter, OrderFilter, TextFilter, TimeDeltaFilter, TimeFilter
from strawberry import UNSET, Private
import strawberry
@strawberry.input(name='ArrayComparison', description=_DESCRIPTION.format(field='List fields'))
class ArrayComparison(EqualityComparison[T], Generic[T]):
"""Postgres array comparison class for GraphQL filters.
This class provides a set of array comparison operators that can be
used to filter data based on containment, overlap, and other
array-specific properties.
Attributes:
contains: Filters for array values that contain all elements in this list.
contained_in: Filters for array values that are contained in this list.
overlap: Filters for array values that have any elements in common with this list.
"""
__strawchemy_filter__ = ArrayFilter
contains: Optional[list[T]] = UNSET
contained_in: Optional[list[T]] = UNSET
overlap: Optional[list[T]] = UNSET
| null | 2
| 1
| 0
| 0
| 0
| 0
| 0
| 1.8
| 2
| 0
| 0
| 0
| 0
| 0
| 0
| 5
| 18
| 4
| 5
| 5
| 4
| 9
| 5
| 5
| 4
| 0
| 2
| 0
| 0
|
328,065
|
gazorby/strawchemy
|
/Users/umroot/Documents/PhD_works/PhD-Core-Contents/Class-level-dataset-curation/unseen_data/git_repos_for_analysis/gazorby_strawchemy/src/strawchemy/strawberry/filters/inputs.py
|
strawchemy.strawberry.filters.inputs.DateComparison
|
from typing import TYPE_CHECKING, Any, Generic, Optional, TypeVar, Union
from .base import ArrayFilter, DateFilter, DateTimeFilter, EqualityFilter, FilterProtocol, JSONFilter, OrderFilter, TextFilter, TimeDeltaFilter, TimeFilter
from datetime import date, datetime, time, timedelta
from strawberry import UNSET, Private
import strawberry
@strawberry.input(name='DateComparison', description=_DESCRIPTION.format(field='Date fields'))
class DateComparison(OrderComparison[date]):
"""Date comparison class for GraphQL filters.
This class provides a set of date component comparison operators that
can be used to filter data based on specific parts of a date.
Attributes:
year: Filters based on the year.
month: Filters based on the month.
day: Filters based on the day.
week_day: Filters based on the day of the week.
week: Filters based on the week number.
quarter: Filters based on the quarter of the year.
iso_year: Filters based on the ISO year.
iso_week_day: Filters based on the ISO day of the week.
"""
__strawchemy_filter__ = DateFilter
year: Optional[OrderComparison[int]] = UNSET
month: Optional[OrderComparison[int]] = UNSET
day: Optional[OrderComparison[int]] = UNSET
week_day: Optional[OrderComparison[int]] = UNSET
week: Optional[OrderComparison[int]] = UNSET
quarter: Optional[OrderComparison[int]] = UNSET
iso_year: Optional[OrderComparison[int]] = UNSET
iso_week_day: Optional[OrderComparison[int]] = UNSET
| null | 2
| 1
| 0
| 0
| 0
| 0
| 0
| 1.3
| 1
| 0
| 0
| 0
| 0
| 0
| 0
| 5
| 27
| 4
| 10
| 10
| 9
| 13
| 10
| 10
| 9
| 0
| 3
| 0
| 0
|
328,066
|
gazorby/strawchemy
|
/Users/umroot/Documents/PhD_works/PhD-Core-Contents/Class-level-dataset-curation/unseen_data/git_repos_for_analysis/gazorby_strawchemy/src/strawchemy/strawberry/filters/inputs.py
|
strawchemy.strawberry.filters.inputs.DateTimeComparison
|
import strawberry
from datetime import date, datetime, time, timedelta
from .base import ArrayFilter, DateFilter, DateTimeFilter, EqualityFilter, FilterProtocol, JSONFilter, OrderFilter, TextFilter, TimeDeltaFilter, TimeFilter
from typing import TYPE_CHECKING, Any, Generic, Optional, TypeVar, Union
from strawberry import UNSET, Private
@strawberry.input(name='DateTimeComparison', description=_DESCRIPTION.format(field='DateTime fields'))
class DateTimeComparison(OrderComparison[datetime]):
__strawchemy_filter__ = DateTimeFilter
year: Optional[OrderComparison[int]] = UNSET
month: Optional[OrderComparison[int]] = UNSET
day: Optional[OrderComparison[int]] = UNSET
week_day: Optional[OrderComparison[int]] = UNSET
week: Optional[OrderComparison[int]] = UNSET
quarter: Optional[OrderComparison[int]] = UNSET
iso_year: Optional[OrderComparison[int]] = UNSET
iso_week_day: Optional[OrderComparison[int]] = UNSET
hour: Optional[OrderComparison[int]] = UNSET
minute: Optional[OrderComparison[int]] = UNSET
second: Optional[OrderComparison[int]] = UNSET
|
@strawberry.input(name='DateTimeComparison', description=_DESCRIPTION.format(field='DateTime fields'))
class DateTimeComparison(OrderComparison[datetime]):
pass
| 2
| 0
| 0
| 0
| 0
| 0
| 0
| 0
| 1
| 0
| 0
| 0
| 0
| 0
| 0
| 5
| 15
| 2
| 13
| 13
| 12
| 0
| 13
| 13
| 12
| 0
| 3
| 0
| 0
|
328,067
|
gazorby/strawchemy
|
/Users/umroot/Documents/PhD_works/PhD-Core-Contents/Class-level-dataset-curation/unseen_data/git_repos_for_analysis/gazorby_strawchemy/src/strawchemy/strawberry/filters/inputs.py
|
strawchemy.strawberry.filters.inputs.EqualityComparison
|
from .base import ArrayFilter, DateFilter, DateTimeFilter, EqualityFilter, FilterProtocol, JSONFilter, OrderFilter, TextFilter, TimeDeltaFilter, TimeFilter
from strawberry import UNSET, Private
from typing import TYPE_CHECKING, Any, Generic, Optional, TypeVar, Union
import strawberry
@strawberry.input(name='GenericComparison', description=_DESCRIPTION.format(field='fields supporting equality comparisons'))
class EqualityComparison(GraphQLComparison, Generic[T]):
"""Generic comparison class for GraphQL filters.
This class provides a set of generic comparison operators that can be
used to filter data based on equality, inequality, null checks, and
inclusion in a list.
Attributes:
eq: Filters for values equal to this.
neq: Filters for values not equal to this.
is_null: Filters for null values if True, or non-null values if False.
in: Filters for values present in this list.
nin: Filters for values not present in this list.
"""
__strawchemy_filter__ = EqualityFilter
eq: Optional[T] = UNSET
neq: Optional[T] = UNSET
is_null: Optional[bool] = UNSET
in_: Optional[list[T]] = strawberry.field(name='in', default=UNSET)
nin: Optional[list[T]] = UNSET
| null | 2
| 1
| 0
| 0
| 0
| 0
| 0
| 1.57
| 2
| 0
| 0
| 4
| 0
| 0
| 0
| 5
| 22
| 4
| 7
| 7
| 6
| 11
| 7
| 7
| 6
| 0
| 1
| 0
| 0
|
328,068
|
gazorby/strawchemy
|
/Users/umroot/Documents/PhD_works/PhD-Core-Contents/Class-level-dataset-curation/unseen_data/git_repos_for_analysis/gazorby_strawchemy/src/strawchemy/strawberry/filters/inputs.py
|
strawchemy.strawberry.filters.inputs.GraphQLComparison
|
from strawberry import UNSET, Private
from .base import ArrayFilter, DateFilter, DateTimeFilter, EqualityFilter, FilterProtocol, JSONFilter, OrderFilter, TextFilter, TimeDeltaFilter, TimeFilter
from sqlalchemy import Dialect
from strawchemy.strawberry.typing import QueryNodeType
from typing import TYPE_CHECKING, Any, Generic, Optional, TypeVar, Union
class GraphQLComparison:
"""Base class for GraphQL comparison filters.
This class provides a foundation for creating comparison filters
that can be used in GraphQL queries. It defines the basic structure
and methods for comparing fields of a specific type.
Attributes:
_description: A class variable that stores the description of the
comparison.
_field_node: A private attribute that stores the DTO field node.
"""
__strawchemy_field_node__: Private[Optional[QueryNodeType]] = None
__strawchemy_filter__: Private[type[FilterProtocol]]
def to_expressions(self, dialect: Dialect, model_attribute: Union[QueryableAttribute[Any], ColumnElement[Any]]) -> list[ColumnElement[bool]]:
return self.__strawchemy_filter__(self).to_expressions(dialect, model_attribute)
@property
def field_node(self) -> QueryNodeType:
if self.__strawchemy_field_node__ is None:
raise ValueError
return self.__strawchemy_field_node__
@field_node.setter
def field_node(self, value: QueryNodeType) -> None:
self.__strawchemy_field_node__ = value
|
class GraphQLComparison:
'''Base class for GraphQL comparison filters.
This class provides a foundation for creating comparison filters
that can be used in GraphQL queries. It defines the basic structure
and methods for comparing fields of a specific type.
Attributes:
_description: A class variable that stores the description of the
comparison.
_field_node: A private attribute that stores the DTO field node.
'''
def to_expressions(self, dialect: Dialect, model_attribute: Union[QueryableAttribute[Any], ColumnElement[Any]]) -> list[ColumnElement[bool]]:
pass
@property
def field_node(self) -> QueryNodeType:
pass
@field_node.setter
def field_node(self) -> QueryNodeType:
pass
| 6
| 1
| 3
| 0
| 3
| 0
| 1
| 0.6
| 0
| 4
| 0
| 2
| 3
| 0
| 3
| 3
| 30
| 6
| 15
| 9
| 7
| 9
| 11
| 5
| 7
| 2
| 0
| 1
| 4
|
328,069
|
gazorby/strawchemy
|
/Users/umroot/Documents/PhD_works/PhD-Core-Contents/Class-level-dataset-curation/unseen_data/git_repos_for_analysis/gazorby_strawchemy/src/strawchemy/strawberry/filters/inputs.py
|
strawchemy.strawberry.filters.inputs.OrderComparison
|
from typing import TYPE_CHECKING, Any, Generic, Optional, TypeVar, Union
from .base import ArrayFilter, DateFilter, DateTimeFilter, EqualityFilter, FilterProtocol, JSONFilter, OrderFilter, TextFilter, TimeDeltaFilter, TimeFilter
from strawberry import UNSET, Private
import strawberry
@strawberry.input(name='OrderComparison', description=_DESCRIPTION.format(field='fields supporting order comparisons'))
class OrderComparison(EqualityComparison[T]):
"""Order comparison class for GraphQL filters.
This class provides a set of numeric comparison operators that can be
used to filter data based on greater than, less than, and equality.
Attributes:
gt: Filters for values greater than this.
gte: Filters for values greater than or equal to this.
lt: Filters for values less than this.
lte: Filters for values less than or equal to this.
"""
__strawchemy_filter__ = OrderFilter
gt: Optional[T] = UNSET
gte: Optional[T] = UNSET
lt: Optional[T] = UNSET
lte: Optional[T] = UNSET
| null | 2
| 1
| 0
| 0
| 0
| 0
| 0
| 1.5
| 1
| 0
| 0
| 5
| 0
| 0
| 0
| 5
| 19
| 4
| 6
| 6
| 5
| 9
| 6
| 6
| 5
| 0
| 2
| 0
| 0
|
328,070
|
gazorby/strawchemy
|
/Users/umroot/Documents/PhD_works/PhD-Core-Contents/Class-level-dataset-curation/unseen_data/git_repos_for_analysis/gazorby_strawchemy/src/strawchemy/strawberry/filters/inputs.py
|
strawchemy.strawberry.filters.inputs.TextComparison
|
from typing import TYPE_CHECKING, Any, Generic, Optional, TypeVar, Union
from .base import ArrayFilter, DateFilter, DateTimeFilter, EqualityFilter, FilterProtocol, JSONFilter, OrderFilter, TextFilter, TimeDeltaFilter, TimeFilter
import strawberry
from strawberry import UNSET, Private
@strawberry.input(name='TextComparison', description=_DESCRIPTION.format(field='String fields'))
class TextComparison(OrderComparison[str]):
"""Text comparison class for GraphQL filters.
This class provides a set of text comparison operators that can be
used to filter data based on various string matching patterns.
Attributes:
like: Filters for values that match this SQL LIKE pattern.
nlike: Filters for values that do not match this SQL LIKE pattern.
ilike: Filters for values that match this case-insensitive SQL LIKE pattern.
nilike: Filters for values that do not match this case-insensitive SQL LIKE pattern.
regexp: Filters for values that match this regular expression.
nregexp: Filters for values that do not match this regular expression.
startswith: Filters for values that start with this string.
endswith: Filters for values that end with this string.
contains: Filters for values that contain this string.
istartswith: Filters for values that start with this string (case-insensitive).
iendswith: Filters for values that end with this string (case-insensitive).
icontains: Filters for values that contain this string (case-insensitive).
"""
__strawchemy_filter__ = TextFilter
like: Optional[str] = UNSET
nlike: Optional[str] = UNSET
ilike: Optional[str] = UNSET
nilike: Optional[str] = UNSET
regexp: Optional[str] = UNSET
iregexp: Optional[str] = UNSET
nregexp: Optional[str] = UNSET
inregexp: Optional[str] = UNSET
startswith: Optional[str] = UNSET
endswith: Optional[str] = UNSET
contains: Optional[str] = UNSET
istartswith: Optional[str] = UNSET
iendswith: Optional[str] = UNSET
icontains: Optional[str] = UNSET
| null | 2
| 1
| 0
| 0
| 0
| 0
| 0
| 1.06
| 1
| 0
| 0
| 0
| 0
| 0
| 0
| 5
| 37
| 4
| 16
| 16
| 15
| 17
| 16
| 16
| 15
| 0
| 3
| 0
| 0
|
328,071
|
gazorby/strawchemy
|
/Users/umroot/Documents/PhD_works/PhD-Core-Contents/Class-level-dataset-curation/unseen_data/git_repos_for_analysis/gazorby_strawchemy/src/strawchemy/strawberry/filters/inputs.py
|
strawchemy.strawberry.filters.inputs.TimeComparison
|
from typing import TYPE_CHECKING, Any, Generic, Optional, TypeVar, Union
from .base import ArrayFilter, DateFilter, DateTimeFilter, EqualityFilter, FilterProtocol, JSONFilter, OrderFilter, TextFilter, TimeDeltaFilter, TimeFilter
import strawberry
from datetime import date, datetime, time, timedelta
from strawberry import UNSET, Private
@strawberry.input(name='TimeComparison', description=_DESCRIPTION.format(field='Time fields'))
class TimeComparison(OrderComparison[time]):
"""Time comparison class for GraphQL filters.
This class provides a set of time component comparison operators that
can be used to filter data based on specific parts of a time.
Attributes:
hour: Filters based on the hour.
minute: Filters based on the minute.
second: Filters based on the second.
"""
__strawchemy_filter__ = TimeFilter
hour: Optional[OrderComparison[int]] = UNSET
minute: Optional[OrderComparison[int]] = UNSET
second: Optional[OrderComparison[int]] = UNSET
| null | 2
| 1
| 0
| 0
| 0
| 0
| 0
| 1.6
| 1
| 0
| 0
| 0
| 0
| 0
| 0
| 5
| 17
| 4
| 5
| 5
| 4
| 8
| 5
| 5
| 4
| 0
| 3
| 0
| 0
|
328,072
|
gazorby/strawchemy
|
/Users/umroot/Documents/PhD_works/PhD-Core-Contents/Class-level-dataset-curation/unseen_data/git_repos_for_analysis/gazorby_strawchemy/src/strawchemy/strawberry/filters/inputs.py
|
strawchemy.strawberry.filters.inputs.TimeDeltaComparison
|
from typing import TYPE_CHECKING, Any, Generic, Optional, TypeVar, Union
from strawberry import UNSET, Private
from .base import ArrayFilter, DateFilter, DateTimeFilter, EqualityFilter, FilterProtocol, JSONFilter, OrderFilter, TextFilter, TimeDeltaFilter, TimeFilter
import strawberry
from datetime import date, datetime, time, timedelta
@strawberry.input(name='IntervalComparison', description=_DESCRIPTION.format(field='Interval fields'))
class TimeDeltaComparison(OrderComparison[timedelta]):
__strawchemy_filter__ = TimeDeltaFilter
days: Optional[OrderComparison[float]] = UNSET
hours: Optional[OrderComparison[float]] = UNSET
minutes: Optional[OrderComparison[float]] = UNSET
seconds: Optional[OrderComparison[float]] = UNSET
|
@strawberry.input(name='IntervalComparison', description=_DESCRIPTION.format(field='Interval fields'))
class TimeDeltaComparison(OrderComparison[timedelta]):
pass
| 2
| 0
| 0
| 0
| 0
| 0
| 0
| 0
| 1
| 0
| 0
| 0
| 0
| 0
| 0
| 5
| 7
| 1
| 6
| 6
| 5
| 0
| 6
| 6
| 5
| 0
| 3
| 0
| 0
|
328,073
|
gazorby/strawchemy
|
/Users/umroot/Documents/PhD_works/PhD-Core-Contents/Class-level-dataset-curation/unseen_data/git_repos_for_analysis/gazorby_strawchemy/src/strawchemy/strawberry/filters/inputs.py
|
strawchemy.strawberry.filters.inputs._JSONComparison
|
from strawberry import UNSET, Private
from .base import ArrayFilter, DateFilter, DateTimeFilter, EqualityFilter, FilterProtocol, JSONFilter, OrderFilter, TextFilter, TimeDeltaFilter, TimeFilter
from typing import TYPE_CHECKING, Any, Generic, Optional, TypeVar, Union
class _JSONComparison(EqualityComparison[dict[str, Any]]):
"""JSON comparison class for GraphQL filters.
This class provides a set of JSON comparison operators that can be
used to filter data based on containment, key existence, and other
JSON-specific properties.
Attributes:
contains: Filters for JSON values that contain this JSON object.
contained_in: Filters for JSON values that are contained in this JSON object.
has_key: Filters for JSON values that have this key.
has_key_all: Filters for JSON values that have all of these keys.
has_key_any: Filters for JSON values that have any of these keys.
"""
__strawchemy_filter__ = JSONFilter
contains: Optional[dict[str, Any]] = UNSET
contained_in: Optional[dict[str, Any]] = UNSET
has_key: Optional[str] = UNSET
has_key_all: Optional[list[str]] = UNSET
has_key_any: Optional[list[str]] = UNSET
|
class _JSONComparison(EqualityComparison[dict[str, Any]]):
'''JSON comparison class for GraphQL filters.
This class provides a set of JSON comparison operators that can be
used to filter data based on containment, key existence, and other
JSON-specific properties.
Attributes:
contains: Filters for JSON values that contain this JSON object.
contained_in: Filters for JSON values that are contained in this JSON object.
has_key: Filters for JSON values that have this key.
has_key_all: Filters for JSON values that have all of these keys.
has_key_any: Filters for JSON values that have any of these keys.
'''
pass
| 1
| 1
| 0
| 0
| 0
| 0
| 0
| 1.57
| 1
| 0
| 0
| 0
| 0
| 0
| 0
| 5
| 22
| 4
| 7
| 7
| 6
| 11
| 7
| 7
| 6
| 0
| 2
| 0
| 0
|
328,074
|
gazorby/strawchemy
|
/Users/umroot/Documents/PhD_works/PhD-Core-Contents/Class-level-dataset-curation/unseen_data/git_repos_for_analysis/gazorby_strawchemy/src/strawchemy/strawberry/filters/inputs.py
|
strawchemy.strawberry.filters.inputs._SQLiteJSONComparison
|
from strawberry import UNSET, Private
from .base import ArrayFilter, DateFilter, DateTimeFilter, EqualityFilter, FilterProtocol, JSONFilter, OrderFilter, TextFilter, TimeDeltaFilter, TimeFilter
from typing import TYPE_CHECKING, Any, Generic, Optional, TypeVar, Union
class _SQLiteJSONComparison(EqualityComparison[dict[str, Any]]):
"""JSON comparison class for GraphQL filters.
This class provides a set of JSON comparison operators that can be
used to filter data based on containment, key existence, and other
JSON-specific properties.
Attributes:
contains: Filters for JSON values that contain this JSON object.
contained_in: Filters for JSON values that are contained in this JSON object.
has_key: Filters for JSON values that have this key.
has_key_all: Filters for JSON values that have all of these keys.
has_key_any: Filters for JSON values that have any of these keys.
"""
__strawchemy_filter__ = JSONFilter
has_key: Optional[str] = UNSET
has_key_all: Optional[list[str]] = UNSET
has_key_any: Optional[list[str]] = UNSET
|
class _SQLiteJSONComparison(EqualityComparison[dict[str, Any]]):
'''JSON comparison class for GraphQL filters.
This class provides a set of JSON comparison operators that can be
used to filter data based on containment, key existence, and other
JSON-specific properties.
Attributes:
contains: Filters for JSON values that contain this JSON object.
contained_in: Filters for JSON values that are contained in this JSON object.
has_key: Filters for JSON values that have this key.
has_key_all: Filters for JSON values that have all of these keys.
has_key_any: Filters for JSON values that have any of these keys.
'''
pass
| 1
| 1
| 0
| 0
| 0
| 0
| 0
| 2.2
| 1
| 0
| 0
| 0
| 0
| 0
| 0
| 5
| 20
| 4
| 5
| 5
| 4
| 11
| 5
| 5
| 4
| 0
| 2
| 0
| 0
|
328,075
|
gazorby/strawchemy
|
/Users/umroot/Documents/PhD_works/PhD-Core-Contents/Class-level-dataset-curation/unseen_data/git_repos_for_analysis/gazorby_strawchemy/src/strawchemy/strawberry/geo.py
|
strawchemy.strawberry.geo._GeometryHolder
|
from dataclasses import dataclass
from geojson_pydantic.geometries import Geometry as PydanticGeometry
@dataclass
class _GeometryHolder:
geo: PydanticGeometry
|
@dataclass
class _GeometryHolder:
pass
| 2
| 0
| 0
| 0
| 0
| 0
| 0
| 0
| 0
| 0
| 0
| 0
| 0
| 0
| 0
| 0
| 2
| 0
| 2
| 1
| 1
| 0
| 2
| 1
| 1
| 0
| 0
| 0
| 0
|
328,076
|
gazorby/strawchemy
|
/Users/umroot/Documents/PhD_works/PhD-Core-Contents/Class-level-dataset-curation/unseen_data/git_repos_for_analysis/gazorby_strawchemy/src/strawchemy/strawberry/mutation/input.py
|
strawchemy.strawberry.mutation.input.Input
|
from strawchemy.dto.base import DTOFieldDefinition, MappedDTO, ToMappedProtocol, VisitorProtocol
from typing import TYPE_CHECKING, Any, Generic, Literal, Optional, TypeVar, Union, cast, final
from sqlalchemy.orm import MapperProperty, RelationshipDirection, object_mapper
from collections.abc import Hashable, Iterator, Sequence
from typing_extensions import Self, TypeAlias, override
from sqlalchemy import event, inspect
from .types import RelationType, ToManyCreateInput, ToManyUpdateInput, ToManyUpsertInput, ToOneInput, ToOneUpsertInput
from strawchemy.dto.inspectors.sqlalchemy import SQLAlchemyInspector
class Input(Generic[InputModel]):
def __init__(self, dtos: Union[MappedGraphQLDTO[InputModel], Sequence[MappedGraphQLDTO[InputModel]]], _validation_: Optional[ValidationProtocol[InputModel]]=None, **override: Any) -> None:
self.max_level = 0
self.relations: list[RelationInput] = []
self.instances: list[InputModel] = []
self.dtos: list[MappedDTO[InputModel]] = []
self.validation = _validation_
self.list_input = isinstance(dtos, Sequence)
dtos = dtos if isinstance(dtos, Sequence) else [dtos]
for index, dto in enumerate(dtos):
mapped = dto.to_mapped(visitor=_InputVisitor(self, is_update=dto.__strawchemy_purpose__ in ('update_by_pk_input', 'update_by_filter_input')), override=override)
self.instances.append(mapped)
self.dtos.append(dto)
for relation in self.relations:
if relation.input_index == -1:
relation.input_index = index
@classmethod
def _model_identity(cls, model: DeclarativeBase) -> Hashable:
return inspect(model)
def _add_non_input_relations(self, model: DeclarativeBase, input_index: int, _level: int=0, _seen: Optional[set[Hashable]]=None) -> None:
seen = _seen or set()
_level += 1
level_relations = {relation.attribute.key for relation in self.relations if relation.level == _level}
mapper = object_mapper(model)
seen.add(self._model_identity(model))
for relationship in mapper.relationships:
if relationship.key not in SQLAlchemyInspector.loaded_attributes(model) or relationship.key in level_relations:
continue
relationship_value = getattr(model, relationship.key)
if relationship_value is None:
continue
relation_type = RelationType.TO_MANY if relationship.direction in {RelationshipDirection.MANYTOMANY, RelationshipDirection.ONETOMANY} else RelationType.TO_ONE
relation = RelationInput(attribute=relationship, parent=model, level=_level, input_index=input_index, relation_type=relation_type, related=relationship.entity.mapper.class_)
if isinstance(relationship_value, (tuple, list)):
model_list = cast('list[DeclarativeBase]', relationship_value)
for value in model_list:
if self._model_identity(value) in seen:
continue
self._add_non_input_relations(value, input_index, _level, seen)
relation.add_instance(value)
elif self._model_identity(relationship_value) not in seen:
self._add_non_input_relations(relationship_value, input_index, _level, seen)
relation.add_instance(relationship_value)
self.add_relation(relation)
def add_relation(self, relation: RelationInput) -> None:
if relation:
self.relations.append(relation)
self.max_level = max(self.max_level, relation.level)
def filter_by_level(self, relation_type: RelationType, input_types: Iterable[RelationInputType]) -> list[LevelInput]:
levels: list[LevelInput] = []
level_range = range(1, self.max_level + 1) if relation_type is RelationType.TO_MANY else range(self.max_level, 0, -1)
for level in level_range:
level_input = LevelInput()
for relation in self.relations:
input_data: list[_FilteredRelationInput] = []
for input_type in input_types:
relation_input = getattr(relation, input_type)
if not relation_input or relation.level != level:
continue
input_data.extend((_FilteredRelationInput(relation, mapped) for mapped in relation_input if relation.relation_type is relation_type))
level_input.inputs.extend(input_data)
if level_input.inputs:
levels.append(level_input)
return levels
def add_non_input_relations(self) -> None:
for i, instance in enumerate(self.instances):
self._add_non_input_relations(instance, i)
|
class Input(Generic[InputModel]):
def __init__(self, dtos: Union[MappedGraphQLDTO[InputModel], Sequence[MappedGraphQLDTO[InputModel]]], _validation_: Optional[ValidationProtocol[InputModel]]=None, **override: Any) -> None:
pass
@classmethod
def _model_identity(cls, model: DeclarativeBase) -> Hashable:
pass
def _add_non_input_relations(self, model: DeclarativeBase, input_index: int, _level: int=0, _seen: Optional[set[Hashable]]=None) -> None:
pass
def add_relation(self, relation: RelationInput) -> None:
pass
def filter_by_level(self, relation_type: RelationType, input_types: Iterable[RelationInputType]) -> list[LevelInput]:
pass
def add_non_input_relations(self) -> None:
pass
| 8
| 0
| 17
| 0
| 17
| 0
| 4
| 0.02
| 1
| 18
| 8
| 0
| 5
| 6
| 6
| 8
| 110
| 7
| 101
| 43
| 84
| 2
| 65
| 33
| 58
| 9
| 1
| 4
| 26
|
328,077
|
gazorby/strawchemy
|
/Users/umroot/Documents/PhD_works/PhD-Core-Contents/Class-level-dataset-curation/unseen_data/git_repos_for_analysis/gazorby_strawchemy/src/strawchemy/strawberry/mutation/input.py
|
strawchemy.strawberry.mutation.input.LevelInput
|
from dataclasses import dataclass, field
@dataclass
class LevelInput:
inputs: list[_FilteredRelationInput] = field(default_factory=list)
|
@dataclass
class LevelInput:
pass
| 2
| 0
| 0
| 0
| 0
| 0
| 0
| 0
| 0
| 0
| 0
| 0
| 0
| 0
| 0
| 0
| 2
| 0
| 2
| 2
| 1
| 0
| 2
| 2
| 1
| 0
| 0
| 0
| 0
|
328,078
|
gazorby/strawchemy
|
/Users/umroot/Documents/PhD_works/PhD-Core-Contents/Class-level-dataset-curation/unseen_data/git_repos_for_analysis/gazorby_strawchemy/src/strawchemy/strawberry/mutation/input.py
|
strawchemy.strawberry.mutation.input.RelationInput
|
from typing_extensions import Self, TypeAlias, override
from .types import RelationType, ToManyCreateInput, ToManyUpdateInput, ToManyUpsertInput, ToOneInput, ToOneUpsertInput
from typing import TYPE_CHECKING, Any, Generic, Literal, Optional, TypeVar, Union, cast, final
from sqlalchemy.orm import MapperProperty, RelationshipDirection, object_mapper
from sqlalchemy import event, inspect
class RelationInput(_UnboundRelationInput):
def __init__(self, attribute: MapperProperty[Any], related: type[DeclarativeBase], parent: DeclarativeBase, relation_type: RelationType, set_: Union[list[DeclarativeBase], None, type[_Unset]]=_Unset, add: Optional[list[DeclarativeBase]]=None, remove: Optional[list[DeclarativeBase]]=None, create: Optional[list[DeclarativeBase]]=None, upsert: Optional[UpsertData]=None, input_index: int=-1, level: int=0) -> None:
super().__init__(attribute=attribute, related=related, relation_type=relation_type, set_=set_, add=add, remove=remove, create=create, upsert=upsert, input_index=input_index, level=level)
self.parent = parent
if self.relation_type is RelationType.TO_ONE:
event.listens_for(self.attribute, 'set')(self._set_event)
else:
event.listens_for(self.attribute, 'append')(self._append_event)
event.listens_for(self.attribute, 'remove')(self._remove_event)
@classmethod
def from_unbound(cls, unbound: _UnboundRelationInput, model: DeclarativeBase) -> Self:
return cls(attribute=unbound.attribute, related=unbound.related, parent=model, set_=unbound.set, add=unbound.add, remove=unbound.remove, relation_type=unbound.relation_type, create=unbound.create, input_index=unbound.input_index, level=unbound.level, upsert=unbound.upsert)
def _set_event(self, target: DeclarativeBase, value: Optional[DeclarativeBase], *_: Any, **__: Any) -> None:
if value is None:
return
if _has_record(value):
self.set = [value]
else:
self.create = [value]
def _append_event(self, target: DeclarativeBase, value: DeclarativeBase, *_: Any, **__: Any) -> None:
if _has_record(value):
self.add.append(value)
else:
self.create.append(value)
def _remove_event(self, target: DeclarativeBase, value: DeclarativeBase, *_: Any, **__: Any) -> None:
if _has_record(value):
self.add = [model for model in self.add if model is not value]
else:
self.create = [model for model in self.create if model is not value]
|
class RelationInput(_UnboundRelationInput):
def __init__(self, attribute: MapperProperty[Any], related: type[DeclarativeBase], parent: DeclarativeBase, relation_type: RelationType, set_: Union[list[DeclarativeBase], None, type[_Unset]]=_Unset, add: Optional[list[DeclarativeBase]]=None, remove: Optional[list[DeclarativeBase]]=None, create: Optional[list[DeclarativeBase]]=None, upsert: Optional[UpsertData]=None, input_index: int=-1, level: int=0) -> None:
pass
@classmethod
def from_unbound(cls, unbound: _UnboundRelationInput, model: DeclarativeBase) -> Self:
pass
def _set_event(self, target: DeclarativeBase, value: Optional[DeclarativeBase], *_: Any, **__: Any) -> None:
pass
def _append_event(self, target: DeclarativeBase, value: DeclarativeBase, *_: Any, **__: Any) -> None:
pass
def _remove_event(self, target: DeclarativeBase, value: DeclarativeBase, *_: Any, **__: Any) -> None:
pass
| 7
| 0
| 13
| 0
| 13
| 0
| 2
| 0
| 1
| 8
| 3
| 0
| 4
| 4
| 5
| 8
| 70
| 5
| 65
| 24
| 45
| 0
| 24
| 10
| 18
| 3
| 1
| 1
| 10
|
328,079
|
gazorby/strawchemy
|
/Users/umroot/Documents/PhD_works/PhD-Core-Contents/Class-level-dataset-curation/unseen_data/git_repos_for_analysis/gazorby_strawchemy/src/strawchemy/strawberry/mutation/input.py
|
strawchemy.strawberry.mutation.input.UpsertData
|
from dataclasses import dataclass, field
from collections.abc import Hashable, Iterator, Sequence
from .types import RelationType, ToManyCreateInput, ToManyUpdateInput, ToManyUpsertInput, ToOneInput, ToOneUpsertInput
from typing_extensions import Self, TypeAlias, override
import dataclasses
from typing import TYPE_CHECKING, Any, Generic, Literal, Optional, TypeVar, Union, cast, final
@dataclass(frozen=True)
class UpsertData:
instances: list[DeclarativeBase] = dataclasses.field(default_factory=list)
conflict_constraint: Optional[Enum] = None
update_fields: list[EnumDTO] = dataclasses.field(default_factory=list)
@classmethod
def from_upsert_input(cls, data: Union[ToOneUpsertInput[Any, Any, Any], ToManyUpsertInput[Any, Any, Any]]) -> Self:
instances = data.to_mapped()
return cls(instances=instances if isinstance(instances, list) else [instances], update_fields=data.update_fields or [], conflict_constraint=data.conflict_fields)
def __iter__(self) -> Iterator[DeclarativeBase]:
return iter(self.instances)
|
@dataclass(frozen=True)
class UpsertData:
@classmethod
def from_upsert_input(cls, data: Union[ToOneUpsertInput[Any, Any, Any], ToManyUpsertInput[Any, Any, Any]]) -> Self:
pass
def __iter__(self) -> Iterator[DeclarativeBase]:
pass
| 5
| 0
| 5
| 0
| 5
| 0
| 2
| 0
| 0
| 5
| 2
| 0
| 1
| 0
| 2
| 2
| 16
| 2
| 14
| 8
| 10
| 0
| 9
| 7
| 6
| 2
| 0
| 0
| 3
|
328,080
|
gazorby/strawchemy
|
/Users/umroot/Documents/PhD_works/PhD-Core-Contents/Class-level-dataset-curation/unseen_data/git_repos_for_analysis/gazorby_strawchemy/src/strawchemy/strawberry/mutation/input.py
|
strawchemy.strawberry.mutation.input._FilteredRelationInput
|
from dataclasses import dataclass, field
@dataclass
class _FilteredRelationInput:
relation: RelationInput
instance: DeclarativeBase
|
@dataclass
class _FilteredRelationInput:
pass
| 2
| 0
| 0
| 0
| 0
| 0
| 0
| 0
| 0
| 0
| 0
| 0
| 0
| 0
| 0
| 0
| 3
| 0
| 3
| 1
| 2
| 0
| 3
| 1
| 2
| 0
| 0
| 0
| 0
|
328,081
|
gazorby/strawchemy
|
/Users/umroot/Documents/PhD_works/PhD-Core-Contents/Class-level-dataset-curation/unseen_data/git_repos_for_analysis/gazorby_strawchemy/src/strawchemy/strawberry/mutation/input.py
|
strawchemy.strawberry.mutation.input._InputVisitor
|
from .types import RelationType, ToManyCreateInput, ToManyUpdateInput, ToManyUpsertInput, ToOneInput, ToOneUpsertInput
from typing import TYPE_CHECKING, Any, Generic, Literal, Optional, TypeVar, Union, cast, final
from strawchemy.dto.inspectors.sqlalchemy import SQLAlchemyInspector
import dataclasses
from strawchemy.dto.base import DTOFieldDefinition, MappedDTO, ToMappedProtocol, VisitorProtocol
from typing_extensions import Self, TypeAlias, override
from dataclasses import dataclass, field
@dataclass
class _InputVisitor(VisitorProtocol[DeclarativeBaseT], Generic[DeclarativeBaseT, InputModel]):
input_data: Input[InputModel]
is_update: bool = False
current_relations: list[_UnboundRelationInput] = dataclasses.field(default_factory=list)
@override
def field_value(self, parent: ToMappedProtocol[DeclarativeBaseT], field: DTOFieldDefinition[DeclarativeBase, QueryableAttribute[Any]], value: Any, level: int) -> Any:
field_value = getattr(parent, field.model_field_name)
add, remove, create = ([], [], [])
set_: Optional[list[Any]] = []
upsert: Optional[UpsertData] = None
relation_type = RelationType.TO_MANY
if isinstance(field_value, ToOneInput):
relation_type = RelationType.TO_ONE
if field_value.set is None:
set_ = None
elif field_value.set:
set_ = [field_value.set.to_mapped()]
elif isinstance(field_value, (ToManyUpdateInput, ToManyCreateInput)):
if field_value.set:
set_ = [dto.to_mapped() for dto in field_value.set]
if field_value.add:
add = [dto.to_mapped() for dto in field_value.add]
if isinstance(field_value, ToManyUpdateInput) and field_value.remove:
remove = [dto.to_mapped() for dto in field_value.remove]
if isinstance(field_value, (ToOneInput, ToManyUpdateInput, ToManyCreateInput)):
if field_value.create:
create = value if isinstance(value, list) else [value]
if field_value.upsert:
upsert = UpsertData.from_upsert_input(field_value.upsert)
if set_ is None or set_ or add or remove or create or (upsert is not None):
assert field.related_model
self.current_relations.append(_UnboundRelationInput(attribute=field.model_field.property, related=field.related_model, relation_type=relation_type, set_=set_, add=add, remove=remove, create=create, level=level, upsert=upsert))
return value
@override
def model(self, parent: ToMappedProtocol[DeclarativeBaseT], model_cls: type[DeclarativeBaseT], params: dict[str, Any], override: dict[str, Any], level: int) -> Any:
if level == 1 and self.input_data.validation is not None:
model = self.input_data.validation.validate(**params).to_mapped(override=override)
else:
model = model_cls(**params)
if self.is_update:
for attribute in SQLAlchemyInspector.loaded_attributes(model):
if attribute not in params:
delattr(model, attribute)
for relation in self.current_relations:
self.input_data.add_relation(RelationInput.from_unbound(relation, model))
self.current_relations.clear()
return model if level == 1 or self.input_data.validation is None else params
|
@dataclass
class _InputVisitor(VisitorProtocol[DeclarativeBaseT], Generic[DeclarativeBaseT, InputModel]):
@override
def field_value(self, parent: ToMappedProtocol[DeclarativeBaseT], field: DTOFieldDefinition[DeclarativeBase, QueryableAttribute[Any]], value: Any, level: int) -> Any:
pass
@override
def model(self, parent: ToMappedProtocol[DeclarativeBaseT], model_cls: type[DeclarativeBaseT], params: dict[str, Any], override: dict[str, Any], level: int) -> Any:
pass
| 6
| 0
| 35
| 1
| 33
| 1
| 10
| 0.03
| 2
| 15
| 10
| 0
| 2
| 0
| 2
| 28
| 79
| 5
| 72
| 28
| 54
| 2
| 42
| 13
| 39
| 13
| 6
| 3
| 20
|
328,082
|
gazorby/strawchemy
|
/Users/umroot/Documents/PhD_works/PhD-Core-Contents/Class-level-dataset-curation/unseen_data/git_repos_for_analysis/gazorby_strawchemy/src/strawchemy/strawberry/mutation/input.py
|
strawchemy.strawberry.mutation.input._UnboundRelationInput
|
from sqlalchemy.orm import MapperProperty, RelationshipDirection, object_mapper
from typing import TYPE_CHECKING, Any, Generic, Literal, Optional, TypeVar, Union, cast, final
from .types import RelationType, ToManyCreateInput, ToManyUpdateInput, ToManyUpsertInput, ToOneInput, ToOneUpsertInput
class _UnboundRelationInput:
def __init__(self, attribute: MapperProperty[Any], related: type[DeclarativeBase], relation_type: RelationType, set_: Union[list[DeclarativeBase], None, type[_Unset]]=_Unset, add: Optional[list[DeclarativeBase]]=None, remove: Optional[list[DeclarativeBase]]=None, create: Optional[list[DeclarativeBase]]=None, upsert: Optional[UpsertData]=None, input_index: int=-1, level: int=0) -> None:
self.attribute = attribute
self.related = related
self.relation_type = relation_type
self.set: Optional[list[DeclarativeBase]] = set_ if set_ is not _Unset else []
self.add = add if add is not None else []
self.remove = remove if remove is not None else []
self.create = create if create is not None else []
self.upsert = upsert
self.input_index = input_index
self.level = level
def add_instance(self, model: DeclarativeBase) -> None:
if not _has_record(model):
self.create.append(model)
elif self.relation_type is RelationType.TO_ONE:
if self.set:
self.set.append(model)
else:
self.set = [model]
else:
self.add.append(model)
def __bool__(self) -> bool:
return bool(self.set or self.add or self.remove or self.create or self.upsert) or self.set is None
|
class _UnboundRelationInput:
def __init__(self, attribute: MapperProperty[Any], related: type[DeclarativeBase], relation_type: RelationType, set_: Union[list[DeclarativeBase], None, type[_Unset]]=_Unset, add: Optional[list[DeclarativeBase]]=None, remove: Optional[list[DeclarativeBase]]=None, create: Optional[list[DeclarativeBase]]=None, upsert: Optional[UpsertData]=None, input_index: int=-1, level: int=0) -> None:
pass
def add_instance(self, model: DeclarativeBase) -> None:
pass
def __bool__(self) -> bool:
pass
| 4
| 0
| 12
| 0
| 12
| 0
| 3
| 0
| 0
| 8
| 3
| 1
| 3
| 10
| 3
| 3
| 38
| 2
| 36
| 26
| 20
| 0
| 21
| 14
| 17
| 5
| 0
| 2
| 10
|
328,083
|
gazorby/strawchemy
|
/Users/umroot/Documents/PhD_works/PhD-Core-Contents/Class-level-dataset-curation/unseen_data/git_repos_for_analysis/gazorby_strawchemy/src/strawchemy/strawberry/mutation/input.py
|
strawchemy.strawberry.mutation.input._Unset
|
from typing import TYPE_CHECKING, Any, Generic, Literal, Optional, TypeVar, Union, cast, final
@final
class _Unset:
...
|
@final
class _Unset:
pass
| 2
| 0
| 0
| 0
| 0
| 0
| 0
| 0
| 0
| 0
| 0
| 0
| 0
| 0
| 0
| 0
| 1
| 0
| 1
| 1
| 1
| 0
| 2
| 1
| 1
| 0
| 0
| 0
| 0
|
328,084
|
gazorby/strawchemy
|
/Users/umroot/Documents/PhD_works/PhD-Core-Contents/Class-level-dataset-curation/unseen_data/git_repos_for_analysis/gazorby_strawchemy/src/strawchemy/strawberry/mutation/types.py
|
strawchemy.strawberry.mutation.types.ErrorId
|
from enum import Enum, auto
class ErrorId(Enum):
ERROR = 'ERROR'
VALIDATION_ERROR = 'VALIDATION_ERROR'
LOCALIZED_VALIDATION_ERROR = 'LOCALIZED_VALIDATION_ERROR'
|
class ErrorId(Enum):
pass
| 1
| 0
| 0
| 0
| 0
| 0
| 0
| 0
| 1
| 0
| 0
| 0
| 0
| 0
| 0
| 49
| 4
| 0
| 4
| 4
| 3
| 0
| 4
| 4
| 3
| 0
| 4
| 0
| 0
|
328,085
|
gazorby/strawchemy
|
/Users/umroot/Documents/PhD_works/PhD-Core-Contents/Class-level-dataset-curation/unseen_data/git_repos_for_analysis/gazorby_strawchemy/src/strawchemy/strawberry/mutation/types.py
|
strawchemy.strawberry.mutation.types.ErrorType
|
from typing import TYPE_CHECKING, Any, ClassVar, Generic, Optional, TypeVar, Union
import strawberry
@strawberry.interface(description='Base interface for expected errors', name='ErrorType')
class ErrorType:
"""Base class for GraphQL errors."""
__error_types__: ClassVar[set[type[Any]]] = set()
id: str = ErrorId.ERROR.value
def __init_subclass__(cls) -> None:
if not cls.__error_types__:
cls.__error_types__.add(ErrorType)
cls.__error_types__.add(cls)
|
@strawberry.interface(description='Base interface for expected errors', name='ErrorType')
class ErrorType:
'''Base class for GraphQL errors.'''
def __init_subclass__(cls) -> None:
pass
| 3
| 1
| 4
| 0
| 4
| 0
| 2
| 0.14
| 0
| 0
| 0
| 2
| 1
| 0
| 1
| 1
| 11
| 3
| 7
| 3
| 5
| 1
| 7
| 3
| 5
| 2
| 0
| 1
| 2
|
328,086
|
gazorby/strawchemy
|
/Users/umroot/Documents/PhD_works/PhD-Core-Contents/Class-level-dataset-curation/unseen_data/git_repos_for_analysis/gazorby_strawchemy/src/strawchemy/strawberry/mutation/types.py
|
strawchemy.strawberry.mutation.types.LocalizedErrorType
|
import strawberry
@strawberry.type(description='Indicate validation error type and location.', name='LocalizedErrorType')
class LocalizedErrorType(ErrorType):
"""Match inner shape of pydantic ValidationError."""
id = ErrorId.LOCALIZED_VALIDATION_ERROR.value
loc: list[str] = strawberry.field(default_factory=list)
message: str
type: str
|
@strawberry.type(description='Indicate validation error type and location.', name='LocalizedErrorType')
class LocalizedErrorType(ErrorType):
'''Match inner shape of pydantic ValidationError.'''
pass
| 2
| 1
| 0
| 0
| 0
| 0
| 0
| 0.2
| 1
| 0
| 0
| 0
| 0
| 0
| 0
| 1
| 7
| 1
| 5
| 2
| 4
| 1
| 5
| 2
| 4
| 0
| 1
| 0
| 0
|
328,087
|
gazorby/strawchemy
|
/Users/umroot/Documents/PhD_works/PhD-Core-Contents/Class-level-dataset-curation/unseen_data/git_repos_for_analysis/gazorby_strawchemy/src/strawchemy/strawberry/mutation/types.py
|
strawchemy.strawberry.mutation.types.RelationType
|
from enum import Enum, auto
class RelationType(Enum):
TO_ONE = auto()
TO_MANY = auto()
|
class RelationType(Enum):
pass
| 1
| 0
| 0
| 0
| 0
| 0
| 0
| 0
| 1
| 0
| 0
| 0
| 0
| 0
| 0
| 49
| 3
| 0
| 3
| 3
| 2
| 0
| 3
| 3
| 2
| 0
| 4
| 0
| 0
|
328,088
|
gazorby/strawchemy
|
/Users/umroot/Documents/PhD_works/PhD-Core-Contents/Class-level-dataset-curation/unseen_data/git_repos_for_analysis/gazorby_strawchemy/src/strawchemy/strawberry/mutation/types.py
|
strawchemy.strawberry.mutation.types.RequiredToManyUpdateInput
|
from typing import TYPE_CHECKING, Any, ClassVar, Generic, Optional, TypeVar, Union
from typing_extensions import override
import strawberry
from strawchemy.dto.types import DTOUnset
from strawberry import UNSET
from strawchemy.dto.base import MappedDTO, ToMappedProtocol, VisitorProtocol
@strawberry.input(description=_TO_MANY_UPDATE_DESCRIPTION)
class RequiredToManyUpdateInput(ToMappedProtocol[Any], Generic[T, RelationInputT, UpdateFieldsT, ConflictFieldsT]):
set: Optional[list[T]] = UNSET
add: Optional[list[T]] = UNSET
create: Optional[list[RelationInputT]] = UNSET
upsert: Optional[ToManyUpsertInput[UpdateFieldsT, ConflictFieldsT, RelationInputT]] = UNSET
@override
def to_mapped(self, visitor: Optional[VisitorProtocol[Any]]=None, override: Optional[dict[str, Any]]=None, level: int=0) -> Union[list[Any], type[DTOUnset]]:
if self.create:
return [dto.to_mapped(visitor, level=level, override=override) for dto in self.create]
if self.upsert:
return self.upsert.to_mapped(visitor, level=level, override=override)
return DTOUnset
|
@strawberry.input(description=_TO_MANY_UPDATE_DESCRIPTION)
class RequiredToManyUpdateInput(ToMappedProtocol[Any], Generic[T, RelationInputT, UpdateFieldsT, ConflictFieldsT]):
@override
def to_mapped(self, visitor: Optional[VisitorProtocol[Any]]=None, override: Optional[dict[str, Any]]=None, level: int=0) -> Union[list[Any], type[DTOUnset]]:
pass
| 4
| 0
| 11
| 0
| 11
| 0
| 3
| 0
| 2
| 7
| 2
| 1
| 1
| 0
| 1
| 26
| 18
| 1
| 17
| 12
| 9
| 0
| 11
| 6
| 9
| 3
| 6
| 1
| 3
|
328,089
|
gazorby/strawchemy
|
/Users/umroot/Documents/PhD_works/PhD-Core-Contents/Class-level-dataset-curation/unseen_data/git_repos_for_analysis/gazorby_strawchemy/src/strawchemy/strawberry/mutation/types.py
|
strawchemy.strawberry.mutation.types.RequiredToOneInput
|
from strawberry import UNSET
from strawchemy.dto.types import DTOUnset
from strawchemy.dto.base import MappedDTO, ToMappedProtocol, VisitorProtocol
from typing import TYPE_CHECKING, Any, ClassVar, Generic, Optional, TypeVar, Union
import strawberry
from typing_extensions import override
@strawberry.input(description=_TO_ONE_DESCRIPTION)
class RequiredToOneInput(ToOneInput[T, RelationInputT, UpdateFieldsT, ConflictFieldsT]):
set: Optional[T] = UNSET
create: Optional[RelationInputT] = UNSET
upsert: Optional[ToOneUpsertInput[UpdateFieldsT, ConflictFieldsT, RelationInputT]] = UNSET
@override
def to_mapped(self, visitor: Optional[VisitorProtocol[Any]]=None, override: Optional[dict[str, Any]]=None, level: int=0) -> Union[Any, type[DTOUnset]]:
if not self.create and (not self.set):
msg = 'Relation is required, you must set either `set`, `create` or `upsert`.'
raise ValueError(msg)
return super().to_mapped(visitor, level=level, override=override)
|
@strawberry.input(description=_TO_ONE_DESCRIPTION)
class RequiredToOneInput(ToOneInput[T, RelationInputT, UpdateFieldsT, ConflictFieldsT]):
@override
def to_mapped(self, visitor: Optional[VisitorProtocol[Any]]=None, override: Optional[dict[str, Any]]=None, level: int=0) -> Union[Any, type[DTOUnset]]:
pass
| 4
| 0
| 10
| 0
| 10
| 0
| 2
| 0
| 1
| 8
| 2
| 0
| 1
| 0
| 1
| 27
| 16
| 1
| 15
| 12
| 7
| 0
| 9
| 6
| 7
| 2
| 7
| 1
| 2
|
328,090
|
gazorby/strawchemy
|
/Users/umroot/Documents/PhD_works/PhD-Core-Contents/Class-level-dataset-curation/unseen_data/git_repos_for_analysis/gazorby_strawchemy/src/strawchemy/strawberry/mutation/types.py
|
strawchemy.strawberry.mutation.types.ToManyCreateInput
|
from typing import TYPE_CHECKING, Any, ClassVar, Generic, Optional, TypeVar, Union
from strawberry import UNSET
from strawchemy.dto.types import DTOUnset
from strawchemy.dto.base import MappedDTO, ToMappedProtocol, VisitorProtocol
from typing_extensions import override
import strawberry
@strawberry.input(description=_TO_MANY_DESCRIPTION)
class ToManyCreateInput(ToMappedProtocol[Any], Generic[T, RelationInputT, UpdateFieldsT, ConflictFieldsT]):
set: Optional[list[T]] = UNSET
add: Optional[list[T]] = UNSET
create: Optional[list[RelationInputT]] = UNSET
upsert: Optional[ToManyUpsertInput[UpdateFieldsT, ConflictFieldsT, RelationInputT]] = UNSET
@override
def to_mapped(self, visitor: Optional[VisitorProtocol[Any]]=None, override: Optional[dict[str, Any]]=None, level: int=0) -> Union[list[Any], type[DTOUnset]]:
if self.set and (self.create or self.upsert or self.add):
msg = 'You cannot use `set` with `create`, `upsert` or `add` in a -to-many relation input'
raise ValueError(msg)
if self.create:
return [dto.to_mapped(visitor, level=level, override=override) for dto in self.create]
if self.upsert:
return self.upsert.to_mapped(visitor, level=level, override=override)
return DTOUnset
|
@strawberry.input(description=_TO_MANY_DESCRIPTION)
class ToManyCreateInput(ToMappedProtocol[Any], Generic[T, RelationInputT, UpdateFieldsT, ConflictFieldsT]):
@override
def to_mapped(self, visitor: Optional[VisitorProtocol[Any]]=None, override: Optional[dict[str, Any]]=None, level: int=0) -> Union[list[Any], type[DTOUnset]]:
pass
| 4
| 0
| 14
| 0
| 14
| 0
| 4
| 0
| 2
| 8
| 2
| 0
| 1
| 0
| 1
| 26
| 21
| 1
| 20
| 13
| 12
| 0
| 14
| 7
| 12
| 4
| 6
| 1
| 4
|
328,091
|
gazorby/strawchemy
|
/Users/umroot/Documents/PhD_works/PhD-Core-Contents/Class-level-dataset-curation/unseen_data/git_repos_for_analysis/gazorby_strawchemy/src/strawchemy/strawberry/mutation/types.py
|
strawchemy.strawberry.mutation.types.ToManyUpdateInput
|
from strawchemy.dto.types import DTOUnset
import strawberry
from typing_extensions import override
from strawchemy.dto.base import MappedDTO, ToMappedProtocol, VisitorProtocol
from strawberry import UNSET
from typing import TYPE_CHECKING, Any, ClassVar, Generic, Optional, TypeVar, Union
@strawberry.input(description=_TO_MANY_UPDATE_DESCRIPTION)
class ToManyUpdateInput(RequiredToManyUpdateInput[T, RelationInputT, UpdateFieldsT, ConflictFieldsT]):
set: Optional[list[T]] = UNSET
add: Optional[list[T]] = UNSET
remove: Optional[list[T]] = UNSET
create: Optional[list[RelationInputT]] = UNSET
upsert: Optional[ToManyUpsertInput[UpdateFieldsT, ConflictFieldsT, RelationInputT]] = UNSET
@override
def to_mapped(self, visitor: Optional[VisitorProtocol[Any]]=None, override: Optional[dict[str, Any]]=None, level: int=0) -> Union[list[Any], type[DTOUnset]]:
if self.set and (self.create or self.add or self.remove):
msg = 'You cannot use `set` with `create`, `upsert`, `add` or `remove` in a -to-many relation input'
raise ValueError(msg)
return super().to_mapped(visitor, level=level, override=override)
|
@strawberry.input(description=_TO_MANY_UPDATE_DESCRIPTION)
class ToManyUpdateInput(RequiredToManyUpdateInput[T, RelationInputT, UpdateFieldsT, ConflictFieldsT]):
@override
def to_mapped(self, visitor: Optional[VisitorProtocol[Any]]=None, override: Optional[dict[str, Any]]=None, level: int=0) -> Union[list[Any], type[DTOUnset]]:
pass
| 4
| 0
| 10
| 0
| 10
| 0
| 2
| 0
| 1
| 9
| 2
| 0
| 1
| 0
| 1
| 27
| 18
| 1
| 17
| 14
| 9
| 0
| 11
| 8
| 9
| 2
| 7
| 1
| 2
|
328,092
|
gazorby/strawchemy
|
/Users/umroot/Documents/PhD_works/PhD-Core-Contents/Class-level-dataset-curation/unseen_data/git_repos_for_analysis/gazorby_strawchemy/src/strawchemy/strawberry/mutation/types.py
|
strawchemy.strawberry.mutation.types.ToManyUpsertInput
|
import strawberry
from strawberry import UNSET
from typing import TYPE_CHECKING, Any, ClassVar, Generic, Optional, TypeVar, Union
from strawchemy.dto.base import MappedDTO, ToMappedProtocol, VisitorProtocol
from typing_extensions import override
@strawberry.input(description='Add new objects or update if existing')
class ToManyUpsertInput(ToMappedProtocol[Any], Generic[UpdateFieldsT, ConflictFieldsT, RelationInputT]):
create: list[RelationInputT]
conflict_fields: ConflictFieldsT
update_fields: Optional[list[UpdateFieldsT]] = UNSET
@override
def to_mapped(self, visitor: Optional[VisitorProtocol[Any]]=None, override: Optional[dict[str, Any]]=None, level: int=0) -> list[Any]:
return [dto.to_mapped(visitor, level=level, override=override) for dto in self.create]
|
@strawberry.input(description='Add new objects or update if existing')
class ToManyUpsertInput(ToMappedProtocol[Any], Generic[UpdateFieldsT, ConflictFieldsT, RelationInputT]):
@override
def to_mapped(self, visitor: Optional[VisitorProtocol[Any]]=None, override: Optional[dict[str, Any]]=None, level: int=0) -> list[Any]:
pass
| 4
| 0
| 7
| 0
| 7
| 0
| 1
| 0
| 2
| 6
| 1
| 0
| 1
| 0
| 1
| 26
| 13
| 1
| 12
| 9
| 4
| 0
| 6
| 3
| 4
| 1
| 6
| 0
| 1
|
328,093
|
gazorby/strawchemy
|
/Users/umroot/Documents/PhD_works/PhD-Core-Contents/Class-level-dataset-curation/unseen_data/git_repos_for_analysis/gazorby_strawchemy/src/strawchemy/strawberry/mutation/types.py
|
strawchemy.strawberry.mutation.types.ToOneInput
|
from strawchemy.dto.base import MappedDTO, ToMappedProtocol, VisitorProtocol
from strawberry import UNSET
from strawchemy.dto.types import DTOUnset
from typing_extensions import override
import strawberry
from typing import TYPE_CHECKING, Any, ClassVar, Generic, Optional, TypeVar, Union
@strawberry.input(description=_TO_ONE_DESCRIPTION)
class ToOneInput(ToMappedProtocol[Any], Generic[T, RelationInputT, UpdateFieldsT, ConflictFieldsT]):
set: Optional[T] = UNSET
create: Optional[RelationInputT] = UNSET
upsert: Optional[ToOneUpsertInput[UpdateFieldsT, ConflictFieldsT, RelationInputT]] = UNSET
@override
def to_mapped(self, visitor: Optional[VisitorProtocol[Any]]=None, override: Optional[dict[str, Any]]=None, level: int=0) -> Union[Any, type[DTOUnset]]:
if (self.create or self.upsert) and self.set:
msg = 'You cannot use `set` along with `create` or `upsert` in a -to-one relation input'
raise ValueError(msg)
if self.create:
return self.create.to_mapped(visitor, level=level, override=override)
if self.upsert:
return self.upsert.to_mapped(visitor, level=level, override=override)
return DTOUnset
|
@strawberry.input(description=_TO_ONE_DESCRIPTION)
class ToOneInput(ToMappedProtocol[Any], Generic[T, RelationInputT, UpdateFieldsT, ConflictFieldsT]):
@override
def to_mapped(self, visitor: Optional[VisitorProtocol[Any]]=None, override: Optional[dict[str, Any]]=None, level: int=0) -> Union[Any, type[DTOUnset]]:
pass
| 4
| 0
| 14
| 0
| 14
| 0
| 4
| 0
| 2
| 7
| 2
| 1
| 1
| 0
| 1
| 26
| 20
| 1
| 19
| 12
| 11
| 0
| 13
| 6
| 11
| 4
| 6
| 1
| 4
|
328,094
|
gazorby/strawchemy
|
/Users/umroot/Documents/PhD_works/PhD-Core-Contents/Class-level-dataset-curation/unseen_data/git_repos_for_analysis/gazorby_strawchemy/src/strawchemy/strawberry/mutation/types.py
|
strawchemy.strawberry.mutation.types.ToOneUpsertInput
|
from typing_extensions import override
from typing import TYPE_CHECKING, Any, ClassVar, Generic, Optional, TypeVar, Union
import strawberry
from strawberry import UNSET
from strawchemy.dto.base import MappedDTO, ToMappedProtocol, VisitorProtocol
@strawberry.input(description='Add new object or update if existing')
class ToOneUpsertInput(ToMappedProtocol[Any], Generic[UpdateFieldsT, ConflictFieldsT, RelationInputT]):
create: RelationInputT
conflict_fields: Optional[ConflictFieldsT] = UNSET
update_fields: Optional[list[UpdateFieldsT]] = UNSET
@override
def to_mapped(self, visitor: Optional[VisitorProtocol[Any]]=None, override: Optional[dict[str, Any]]=None, level: int=0) -> Any:
return self.create.to_mapped(visitor, level=level, override=override)
|
@strawberry.input(description='Add new object or update if existing')
class ToOneUpsertInput(ToMappedProtocol[Any], Generic[UpdateFieldsT, ConflictFieldsT, RelationInputT]):
@override
def to_mapped(self, visitor: Optional[VisitorProtocol[Any]]=None, override: Optional[dict[str, Any]]=None, level: int=0) -> Any:
pass
| 4
| 0
| 7
| 0
| 7
| 0
| 1
| 0
| 2
| 5
| 1
| 0
| 1
| 0
| 1
| 26
| 13
| 1
| 12
| 10
| 4
| 0
| 6
| 4
| 4
| 1
| 6
| 0
| 1
|
328,095
|
gazorby/strawchemy
|
/Users/umroot/Documents/PhD_works/PhD-Core-Contents/Class-level-dataset-curation/unseen_data/git_repos_for_analysis/gazorby_strawchemy/src/strawchemy/strawberry/mutation/types.py
|
strawchemy.strawberry.mutation.types.ValidationErrorType
|
import strawberry
@strawberry.type(description='Input is malformed or invalid.', name='ValidationErrorType')
class ValidationErrorType(ErrorType):
"""Input is malformed or invalid."""
id = ErrorId.VALIDATION_ERROR.value
errors: list[LocalizedErrorType]
|
@strawberry.type(description='Input is malformed or invalid.', name='ValidationErrorType')
class ValidationErrorType(ErrorType):
'''Input is malformed or invalid.'''
pass
| 2
| 1
| 0
| 0
| 0
| 0
| 0
| 0.33
| 1
| 0
| 0
| 0
| 0
| 0
| 0
| 1
| 5
| 1
| 3
| 1
| 2
| 1
| 3
| 1
| 2
| 0
| 1
| 0
| 0
|
328,096
|
gazorby/strawchemy
|
/Users/umroot/Documents/PhD_works/PhD-Core-Contents/Class-level-dataset-curation/unseen_data/git_repos_for_analysis/gazorby_strawchemy/src/strawchemy/strawberry/repository/_async.py
|
strawchemy.strawberry.repository._async.StrawchemyAsyncRepository
|
from typing import TYPE_CHECKING, Any, Optional, TypeVar
from dataclasses import dataclass
from strawchemy.strawberry._utils import default_session_getter, dto_model_from_type, strawberry_contained_user_type
from ._base import GraphQLResult, StrawchemyRepository
from strawchemy.sqlalchemy.repository import SQLAlchemyGraphQLAsyncRepository
@dataclass
class StrawchemyAsyncRepository(StrawchemyRepository[T]):
"""Asynchronous repository implementation for GraphQL data access.
This class provides asynchronous methods for querying and mutating data
through GraphQL, using SQLAlchemy's asynchronous API under the hood.
Args:
type: The Strawberry GraphQL type this repository works with
info: The GraphQL resolver info object
session_getter: Callable to get an async database session
session: Optional explicit async database session to use
filter_statement: Optional base SQLAlchemy select statement to apply to all queries
execution_options: Optional execution options for SQLAlchemy
deterministic_ordering: Whether to ensure deterministic ordering of results
"""
type: type[T]
info: Info[Any, Any]
session_getter: AsyncSessionGetter = default_session_getter
session: Optional[AnyAsyncSession] = None
filter_statement: Optional[Select[tuple[Any]]] = None
execution_options: Optional[dict[str, Any]] = None
deterministic_ordering: bool = False
def graphql_repository(self) -> SQLAlchemyGraphQLAsyncRepository[Any]:
"""Create and configure the underlying async SQLAlchemy GraphQL repository.
Returns:
A configured SQLAlchemyGraphQLAsyncRepository instance
"""
return SQLAlchemyGraphQLAsyncRepository(model=dto_model_from_type(strawberry_contained_user_type(self.type)), session=self.session or self.session_getter(self.info), statement=self.filter_statement, execution_options=self.execution_options, deterministic_ordering=self.deterministic_ordering)
async def get_one_or_none(self, filter_input: Optional[BooleanFilterDTO]=None, order_by: Optional[list[OrderByDTO]]=None, distinct_on: Optional[list[EnumDTO]]=None, limit: Optional[int]=None, offset: Optional[int]=None) -> GraphQLResult[Any, T]:
"""Asynchronously get at most one result matching the criteria or None.
Args:
filter_input: Optional filter conditions
order_by: Optional ordering criteria
distinct_on: Optional fields to apply DISTINCT on
limit: Optional maximum number of results to return
offset: Optional number of results to skip
Returns:
A GraphQLResult containing the result or None
"""
query_results = await self.graphql_repository().get_one(selection=self._tree, dto_filter=filter_input or None, order_by=list(order_by or []), distinct_on=distinct_on, limit=limit, offset=offset, query_hooks=self._query_hooks)
return GraphQLResult(query_results, self._tree)
async def get_one(self, filter_input: Optional[BooleanFilterDTO]=None, order_by: Optional[list[OrderByDTO]]=None, distinct_on: Optional[list[EnumDTO]]=None, limit: Optional[int]=None, offset: Optional[int]=None) -> GraphQLResult[Any, T]:
"""Asynchronously get exactly one result matching the criteria.
Args:
filter_input: Optional filter conditions
order_by: Optional ordering criteria
distinct_on: Optional fields to apply DISTINCT on
limit: Optional maximum number of results to return
offset: Optional number of results to skip
Returns:
A GraphQLResult containing the single result
Raises:
NoResultFound: If no results are found
MultipleResultsFound: If multiple results are found
"""
query_results = await self.graphql_repository().get_one(selection=self._tree, dto_filter=filter_input or None, order_by=list(order_by or []), distinct_on=distinct_on, limit=limit, offset=offset, query_hooks=self._query_hooks)
return GraphQLResult(query_results, self._tree)
async def get_by_id(self, **kwargs: Any) -> GraphQLResult[Any, T]:
"""Asynchronously get an entity by its primary key.
Args:
**kwargs: Primary key field names and values
Returns:
A GraphQLResult containing the found entity
Raises:
NoResultFound: If no entity with the given ID exists
"""
query_results = await self.graphql_repository().get_by_id(selection=self._tree, query_hooks=self._query_hooks, **kwargs)
return GraphQLResult(query_results, self._tree)
async def list(self, filter_input: Optional[BooleanFilterDTO]=None, order_by: Optional[list[OrderByDTO]]=None, distinct_on: Optional[list[EnumDTO]]=None, limit: Optional[int]=None, offset: Optional[int]=None) -> GraphQLResult[Any, T]:
"""Asynchronously get a list of entities matching the criteria.
Args:
filter_input: Optional filter conditions
order_by: Optional ordering criteria
distinct_on: Optional fields to apply DISTINCT on
limit: Optional maximum number of results to return
offset: Optional number of results to skip
Returns:
A GraphQLResult containing the list of matching entities
"""
query_results = await self.graphql_repository().list(selection=self._tree, dto_filter=filter_input or None, order_by=list(order_by or []), distinct_on=distinct_on, limit=limit, offset=offset, query_hooks=self._query_hooks)
return GraphQLResult(query_results, self._tree)
async def create(self, data: Input[InputModel]) -> GraphQLResult[InputModel, T]:
"""Asynchronously create a new entity.
Args:
data: The input data for the new entity
Returns:
A GraphQLResult containing the created entity
"""
query_results = await self.graphql_repository().create(data, self._tree)
return GraphQLResult(query_results, self._tree)
async def upsert(self, data: Input[InputModel], filter_input: Optional[BooleanFilterDTO]=None, update_fields: Optional[list[EnumDTO]]=None, conflict_fields: Optional[EnumDTO]=None) -> GraphQLResult[InputModel, T]:
"""Asynchronously insert or update an entity.
Args:
data: The input data for the entity
filter_input: Optional filter to find existing entity
update_fields: Optional fields to update if entity exists
conflict_fields: Optional fields to detect conflicts on
Returns:
A GraphQLResult containing the upserted entity
"""
query_results = await self.graphql_repository().upsert(data, self._tree, update_fields, conflict_fields, filter_input)
return GraphQLResult(query_results, self._tree)
async def update_by_id(self, data: Input[InputModel]) -> GraphQLResult[InputModel, T]:
"""Asynchronously update an entity by its ID.
Args:
data: The input data containing the ID and fields to update
Returns:
A GraphQLResult containing the updated entity
Raises:
NoResultFound: If no entity with the given ID exists
"""
query_results = await self.graphql_repository().update_by_ids(data, self._tree)
return GraphQLResult(query_results, self._tree)
async def update_by_filter(self, data: Input[InputModel], filter_input: BooleanFilterDTO) -> GraphQLResult[InputModel, T]:
"""Asynchronously update entities matching the given filter.
Args:
data: The input data containing fields to update
filter_input: The filter criteria to select entities to update
Returns:
A GraphQLResult containing the updated entities
"""
query_results = await self.graphql_repository().update_by_filter(data, filter_input, self._tree)
return GraphQLResult(query_results, self._tree)
async def delete(self, filter_input: Optional[BooleanFilterDTO]) -> GraphQLResult[Any, T]:
"""Asynchronously delete entities matching the given filter.
Args:
filter_input: The filter criteria to select entities to delete
Returns:
A GraphQLResult containing the deleted entities
"""
query_results = await self.graphql_repository().delete(self._tree, filter_input or None)
return GraphQLResult(query_results, self._tree)
|
@dataclass
class StrawchemyAsyncRepository(StrawchemyRepository[T]):
'''Asynchronous repository implementation for GraphQL data access.
This class provides asynchronous methods for querying and mutating data
through GraphQL, using SQLAlchemy's asynchronous API under the hood.
Args:
type: The Strawberry GraphQL type this repository works with
info: The GraphQL resolver info object
session_getter: Callable to get an async database session
session: Optional explicit async database session to use
filter_statement: Optional base SQLAlchemy select statement to apply to all queries
execution_options: Optional execution options for SQLAlchemy
deterministic_ordering: Whether to ensure deterministic ordering of results
'''
def graphql_repository(self) -> SQLAlchemyGraphQLAsyncRepository[Any]:
'''Create and configure the underlying async SQLAlchemy GraphQL repository.
Returns:
A configured SQLAlchemyGraphQLAsyncRepository instance
'''
pass
async def get_one_or_none(self, filter_input: Optional[BooleanFilterDTO]=None, order_by: Optional[list[OrderByDTO]]=None, distinct_on: Optional[list[EnumDTO]]=None, limit: Optional[int]=None, offset: Optional[int]=None) -> GraphQLResult[Any, T]:
'''Asynchronously get at most one result matching the criteria or None.
Args:
filter_input: Optional filter conditions
order_by: Optional ordering criteria
distinct_on: Optional fields to apply DISTINCT on
limit: Optional maximum number of results to return
offset: Optional number of results to skip
Returns:
A GraphQLResult containing the result or None
'''
pass
async def get_one_or_none(self, filter_input: Optional[BooleanFilterDTO]=None, order_by: Optional[list[OrderByDTO]]=None, distinct_on: Optional[list[EnumDTO]]=None, limit: Optional[int]=None, offset: Optional[int]=None) -> GraphQLResult[Any, T]:
'''Asynchronously get exactly one result matching the criteria.
Args:
filter_input: Optional filter conditions
order_by: Optional ordering criteria
distinct_on: Optional fields to apply DISTINCT on
limit: Optional maximum number of results to return
offset: Optional number of results to skip
Returns:
A GraphQLResult containing the single result
Raises:
NoResultFound: If no results are found
MultipleResultsFound: If multiple results are found
'''
pass
async def get_by_id(self, **kwargs: Any) -> GraphQLResult[Any, T]:
'''Asynchronously get an entity by its primary key.
Args:
**kwargs: Primary key field names and values
Returns:
A GraphQLResult containing the found entity
Raises:
NoResultFound: If no entity with the given ID exists
'''
pass
async def list(self, filter_input: Optional[BooleanFilterDTO]=None, order_by: Optional[list[OrderByDTO]]=None, distinct_on: Optional[list[EnumDTO]]=None, limit: Optional[int]=None, offset: Optional[int]=None) -> GraphQLResult[Any, T]:
'''Asynchronously get a list of entities matching the criteria.
Args:
filter_input: Optional filter conditions
order_by: Optional ordering criteria
distinct_on: Optional fields to apply DISTINCT on
limit: Optional maximum number of results to return
offset: Optional number of results to skip
Returns:
A GraphQLResult containing the list of matching entities
'''
pass
async def create(self, data: Input[InputModel]) -> GraphQLResult[InputModel, T]:
'''Asynchronously create a new entity.
Args:
data: The input data for the new entity
Returns:
A GraphQLResult containing the created entity
'''
pass
async def upsert(self, data: Input[InputModel], filter_input: Optional[BooleanFilterDTO]=None, update_fields: Optional[list[EnumDTO]]=None, conflict_fields: Optional[EnumDTO]=None) -> GraphQLResult[InputModel, T]:
'''Asynchronously insert or update an entity.
Args:
data: The input data for the entity
filter_input: Optional filter to find existing entity
update_fields: Optional fields to update if entity exists
conflict_fields: Optional fields to detect conflicts on
Returns:
A GraphQLResult containing the upserted entity
'''
pass
async def update_by_id(self, data: Input[InputModel]) -> GraphQLResult[InputModel, T]:
'''Asynchronously update an entity by its ID.
Args:
data: The input data containing the ID and fields to update
Returns:
A GraphQLResult containing the updated entity
Raises:
NoResultFound: If no entity with the given ID exists
'''
pass
async def update_by_filter(self, data: Input[InputModel], filter_input: BooleanFilterDTO) -> GraphQLResult[InputModel, T]:
'''Asynchronously update entities matching the given filter.
Args:
data: The input data containing fields to update
filter_input: The filter criteria to select entities to update
Returns:
A GraphQLResult containing the updated entities
'''
pass
async def delete(self, filter_input: Optional[BooleanFilterDTO]) -> GraphQLResult[Any, T]:
'''Asynchronously delete entities matching the given filter.
Args:
filter_input: The filter criteria to select entities to delete
Returns:
A GraphQLResult containing the deleted entities
'''
pass
| 12
| 11
| 20
| 2
| 9
| 8
| 1
| 0.94
| 1
| 8
| 5
| 0
| 10
| 2
| 10
| 17
| 230
| 36
| 100
| 56
| 60
| 94
| 37
| 25
| 26
| 1
| 2
| 0
| 10
|
328,097
|
gazorby/strawchemy
|
/Users/umroot/Documents/PhD_works/PhD-Core-Contents/Class-level-dataset-curation/unseen_data/git_repos_for_analysis/gazorby_strawchemy/src/strawchemy/strawberry/repository/_base.py
|
strawchemy.strawberry.repository._base.GraphQLResult
|
from ._node import StrawberryQueryNode
from collections.abc import Collection, Sequence
from typing import TYPE_CHECKING, Any, ClassVar, Generic, Literal, Optional, TypeVar, Union, overload
from dataclasses import dataclass
from strawchemy.dto.base import ModelT
@dataclass
class GraphQLResult(Generic[ModelT, T]):
"""Container for GraphQL query results with conversion utilities.
This class provides methods to convert raw query results into their corresponding
GraphQL types, handling both single results and collections.
Attributes:
query_result: The raw query result from the database
tree: The query tree used to construct the result
"""
query_result: QueryResult[ModelT]
tree: StrawberryQueryNode[T]
def graphql_type(self) -> T:
"""Convert the query result to a single GraphQL type.
Returns:
A single instance of the GraphQL type
Raises:
NoResultFound: If no result is found
MultipleResultsFound: If multiple results are found
"""
return self.tree.node_result_to_strawberry_type(self.query_result.one())
def graphql_type_or_none(self) -> Optional[T]:
"""Convert the query result to a single GraphQL type or None.
Returns:
A single instance of the GraphQL type, or None if no result is found
"""
node_result = self.query_result.one_or_none()
return self.tree.node_result_to_strawberry_type(node_result) if node_result else None
@overload
def graphql_list(self, root_aggregations: Literal[False]) -> list[T]:
...
@overload
def graphql_list(self, root_aggregations: Literal[True]) -> T:
...
@overload
def graphql_list(self) -> list[T]:
...
def graphql_list(self, root_aggregations: bool=False) -> Union[list[T], T]:
"""Convert the query result to a list of GraphQL types or aggregated result.
Args:
root_aggregations: If True, returns aggregated results as a single object.
If False, returns a list of individual results.
Returns:
Either a list of GraphQL types or a single aggregated result object,
depending on the root_aggregations flag
"""
if root_aggregations:
return self.tree.aggregation_query_result_to_strawberry_type(self.query_result)
return [self.tree.node_result_to_strawberry_type(node_result) for node_result in self.query_result]
@property
def instances(self) -> Sequence[ModelT]:
"""Get the raw model instances from the query result.
Returns:
A sequence of raw model instances
"""
return self.query_result.nodes
@property
def instance(self) -> ModelT:
"""Get a single raw model instance from the query result.
Returns:
A single model instance
Raises:
NoResultFound: If no result is found
MultipleResultsFound: If multiple results are found
"""
return self.query_result.one().model
|
@dataclass
class GraphQLResult(Generic[ModelT, T]):
'''Container for GraphQL query results with conversion utilities.
This class provides methods to convert raw query results into their corresponding
GraphQL types, handling both single results and collections.
Attributes:
query_result: The raw query result from the database
tree: The query tree used to construct the result
'''
def graphql_type(self) -> T:
'''Convert the query result to a single GraphQL type.
Returns:
A single instance of the GraphQL type
Raises:
NoResultFound: If no result is found
MultipleResultsFound: If multiple results are found
'''
pass
def graphql_type_or_none(self) -> Optional[T]:
'''Convert the query result to a single GraphQL type or None.
Returns:
A single instance of the GraphQL type, or None if no result is found
'''
pass
@overload
def graphql_list(self, root_aggregations: Literal[False]) -> list[T]:
pass
@overload
def graphql_list(self, root_aggregations: Literal[False]) -> list[T]:
pass
@overload
def graphql_list(self, root_aggregations: Literal[False]) -> list[T]:
pass
def graphql_list(self, root_aggregations: Literal[False]) -> list[T]:
'''Convert the query result to a list of GraphQL types or aggregated result.
Args:
root_aggregations: If True, returns aggregated results as a single object.
If False, returns a list of individual results.
Returns:
Either a list of GraphQL types or a single aggregated result object,
depending on the root_aggregations flag
'''
pass
@property
def instances(self) -> Sequence[ModelT]:
'''Get the raw model instances from the query result.
Returns:
A sequence of raw model instances
'''
pass
@property
def instances(self) -> Sequence[ModelT]:
'''Get a single raw model instance from the query result.
Returns:
A single model instance
Raises:
NoResultFound: If no result is found
MultipleResultsFound: If multiple results are found
'''
pass
| 15
| 6
| 7
| 1
| 2
| 4
| 1
| 1.54
| 1
| 3
| 0
| 0
| 8
| 0
| 8
| 10
| 80
| 19
| 24
| 15
| 13
| 37
| 22
| 10
| 13
| 2
| 1
| 1
| 10
|
328,098
|
gazorby/strawchemy
|
/Users/umroot/Documents/PhD_works/PhD-Core-Contents/Class-level-dataset-curation/unseen_data/git_repos_for_analysis/gazorby_strawchemy/src/strawchemy/strawberry/repository/_base.py
|
strawchemy.strawberry.repository._base.StrawchemyRepository
|
from strawberry.types.nodes import FragmentSpread, InlineFragment, SelectedField, Selection
from collections.abc import Collection, Sequence
from typing import TYPE_CHECKING, Any, ClassVar, Generic, Literal, Optional, TypeVar, Union, overload
from strawberry.types import get_object_definition, has_object_definition
from strawchemy.utils import camel_to_snake, snake_keys
from strawchemy.exceptions import StrawchemyError
from strawchemy.strawberry._utils import dto_model_from_type, strawberry_contained_user_type
from strawchemy.constants import JSON_PATH_KEY, ORDER_BY_KEY
from msgspec import convert
from dataclasses import dataclass
from strawberry.types.lazy_type import LazyType
from strawchemy.graph import NodeMetadata
from collections import defaultdict
import dataclasses
from strawchemy.strawberry.dto import DTOKey, OrderByRelationFilterDTO, QueryNode, QueryNodeMetadata, RelationFilterDTO, StrawchemyDTOAttributes
from strawchemy.strawberry.mutation.types import error_type_names
from ._node import StrawberryQueryNode
@dataclass
class StrawchemyRepository(Generic[T]):
"""Base repository for GraphQL data access in Strawchemy.
This class provides the core functionality for building and executing GraphQL queries
against a database, with support for filtering, ordering, and field selection.
Args:
type: The Strawberry GraphQL type this repository works with
info: The GraphQL resolver info object
root_aggregations: Whether to enable root-level aggregations
auto_snake_case: Whether to automatically convert field names to snake_case
Attributes:
_ignored_field_names: Set of field names to ignore during query building
_query_hooks: Dictionary of query hooks registered for different query nodes
_tree: The query tree built from the GraphQL selection
"""
_ignored_field_names: ClassVar[frozenset[str]] = frozenset({'__typename'})
type: type[T]
info: Info[Any, Any]
root_aggregations: bool = False
auto_snake_case: bool = True
_query_hooks: defaultdict[QueryNodeType, list[QueryHook[Any]]] = dataclasses.field(default_factory=lambda: defaultdict(list), init=False)
_tree: StrawberryQueryNode[T] = dataclasses.field(init=False)
def __post_init__(self) -> None:
inner_root_type = strawberry_contained_user_type(self.type)
resolver_selection = next((selection for selection in self.info.selected_fields if isinstance(selection, SelectedField) and selection.name == self.info.field_name))
node = StrawberryQueryNode.root_node(dto_model_from_type(inner_root_type), strawberry_type=inner_root_type, root_aggregations=self.root_aggregations)
self._build(inner_root_type, resolver_selection.selections, node)
self._tree = node.merge_same_children(match_on='value_equality')
def _relation_filter(self, selection: SelectedField, strawberry_field: StrawberryField, arguments: dict[str, Any]) -> RelationFilterDTO:
argument_types = {arg.python_name: arg.type for arg in strawberry_field.arguments}
if (order_by_args := arguments.get(ORDER_BY_KEY)):
if not isinstance(order_by_args, list):
arguments[ORDER_BY_KEY] = [arguments[ORDER_BY_KEY]]
order_by_model = strawberry_contained_user_type(argument_types[ORDER_BY_KEY])
return convert(arguments, type=OrderByRelationFilterDTO[order_by_model], strict=False)
return convert(arguments, type=RelationFilterDTO, strict=False)
@classmethod
def _get_field_hooks(cls, field: StrawberryField) -> Optional[Union[QueryHook[Any], Sequence[QueryHook[Any]]]]:
from strawchemy.strawberry._field import StrawchemyField
return field.query_hook if isinstance(field, StrawchemyField) else None
def _add_query_hooks(self, query_hooks: Union[QueryHook[Any], Sequence[QueryHook[Any]]], node: QueryNodeType) -> None:
hooks = query_hooks if isinstance(query_hooks, Collection) else [query_hooks]
for hook in hooks:
hook.info_var.set(self.info)
self._query_hooks[node].append(hook)
def _build(self, strawberry_type: type[StrawchemyTypeWithStrawberryObjectDefinition], selected_fields: list[Selection], node: QueryNodeType) -> None:
selection_type = strawberry_contained_user_type(strawberry_type)
if isinstance(selection_type, LazyType):
selection_type = selection_type.resolve_type()
strawberry_definition = get_object_definition(selection_type, strict=True)
if selection_type.__strawchemy_query_hook__:
self._add_query_hooks(selection_type.__strawchemy_query_hook__, node)
for selection in selected_fields:
if isinstance(selection, (FragmentSpread, InlineFragment)) and selection.type_condition not in error_type_names():
self._build(strawberry_type, selection.selections, node)
continue
if not isinstance(selection, SelectedField) or selection.name in self._ignored_field_names:
continue
model_field_name = camel_to_snake(selection.name) if self.auto_snake_case else selection.name
strawberry_field = next((field for field in strawberry_definition.fields if field.name == model_field_name))
strawberry_field_type = strawberry_contained_user_type(strawberry_field.type)
dto_model = dto_model_from_type(selection_type)
if (hooks := self._get_field_hooks(strawberry_field)) is not None:
self._add_query_hooks(hooks, node)
if has_object_definition(selection_type):
dto = selection_type
else:
msg = f'Unsupported type: {selection_type}'
raise StrawchemyError(msg)
assert issubclass(dto, StrawchemyDTOAttributes)
key = DTOKey.from_query_node(QueryNode.root_node(dto_model)) + strawberry_field.name
try:
field_definition = dto.__strawchemy_field_map__[key]
except KeyError:
continue
selection_arguments = snake_keys(selection.arguments) if self.auto_snake_case else selection.arguments
child_node = StrawberryQueryNode(value=field_definition, node_metadata=NodeMetadata(QueryNodeMetadata(relation_filter=self._relation_filter(selection, strawberry_field, selection_arguments), strawberry_type=strawberry_field_type, json_path=selection_arguments.get(JSON_PATH_KEY))))
child = node.insert_node(child_node)
if selection.selections:
self._build(strawberry_field_type, selection.selections, child)
|
@dataclass
class StrawchemyRepository(Generic[T]):
'''Base repository for GraphQL data access in Strawchemy.
This class provides the core functionality for building and executing GraphQL queries
against a database, with support for filtering, ordering, and field selection.
Args:
type: The Strawberry GraphQL type this repository works with
info: The GraphQL resolver info object
root_aggregations: Whether to enable root-level aggregations
auto_snake_case: Whether to automatically convert field names to snake_case
Attributes:
_ignored_field_names: Set of field names to ignore during query building
_query_hooks: Dictionary of query hooks registered for different query nodes
_tree: The query tree built from the GraphQL selection
'''
def __post_init__(self) -> None:
pass
def _relation_filter(self, selection: SelectedField, strawberry_field: StrawberryField, arguments: dict[str, Any]) -> RelationFilterDTO:
pass
@classmethod
def _get_field_hooks(cls, field: StrawberryField) -> Optional[Union[QueryHook[Any], Sequence[QueryHook[Any]]]]:
pass
def _add_query_hooks(self, query_hooks: Union[QueryHook[Any], Sequence[QueryHook[Any]]], node: QueryNodeType) -> None:
pass
def _build(self, strawberry_type: type[StrawchemyTypeWithStrawberryObjectDefinition], selected_fields: list[Selection], node: QueryNodeType) -> None:
pass
| 8
| 1
| 19
| 2
| 17
| 0
| 4
| 0.13
| 1
| 19
| 11
| 2
| 4
| 0
| 5
| 7
| 132
| 22
| 97
| 45
| 80
| 13
| 64
| 33
| 57
| 12
| 1
| 2
| 21
|
328,099
|
gazorby/strawchemy
|
/Users/umroot/Documents/PhD_works/PhD-Core-Contents/Class-level-dataset-curation/unseen_data/git_repos_for_analysis/gazorby_strawchemy/src/strawchemy/strawberry/repository/_node.py
|
strawchemy.strawberry.repository._node.StrawberryQueryNode
|
from strawchemy.dto.types import DTOMissing
from typing import TYPE_CHECKING, Any, Generic, Optional, TypeVar, Union, cast
from strawchemy.graph import GraphError
from strawberry.types import get_object_definition
from strawchemy.strawberry._instance import MapperModelInstance
from strawchemy.constants import AGGREGATIONS_KEY, NODES_KEY
from strawberry.utils.typing import type_has_annotation
from dataclasses import dataclass
from strawchemy.strawberry.dto import QueryNode
import dataclasses
@dataclass(eq=False, repr=False)
class StrawberryQueryNode(QueryNode, Generic[T]):
@property
def strawberry_type(self) -> type[T]:
if self.metadata.data.strawberry_type is None:
raise GraphError
return self.metadata.data.strawberry_type
def _model_instance_attribute(self) -> Optional[str]:
return next((field.name for field in dataclasses.fields(cast('DataclassProtocol', self.strawberry_type)) if type_has_annotation(field.type, MapperModelInstance)), None)
@classmethod
def _default_type_kwargs(cls, node: StrawberryQueryNode[Any]) -> dict[str, Any]:
strawberry_definition = get_object_definition(node.strawberry_type, strict=True)
return {field.name: DTOMissing for field in strawberry_definition.fields if field.init}
def computed_value(self, node: QueryNodeType, result: Union[NodeResult[Any], QueryResult[Any]]) -> T:
strawberry_definition = get_object_definition(node.metadata.data.strawberry_type)
if strawberry_definition is None or node.metadata.data.strawberry_type is None:
return result.value(node)
kwargs: dict[str, Any] = {field.name: None for field in strawberry_definition.fields if field.init}
for child in node.children:
kwargs[child.value.name] = self.computed_value(child, result)
return node.metadata.data.strawberry_type(**kwargs)
def node_result_to_strawberry_type(self, node_result: NodeResult[Any]) -> T:
kwargs = self._default_type_kwargs(self)
for child in self.children:
if not isinstance(child, StrawberryQueryNode):
continue
if child.value.is_computed or child.metadata.data.is_transform:
kwargs[child.value.name] = self.computed_value(child, node_result)
elif child.value.is_relation:
value = node_result.value(child)
if isinstance(value, (list, tuple)):
kwargs[child.value.name] = [child.node_result_to_strawberry_type(node_result.copy_with(element)) for element in value]
elif value is not None:
kwargs[child.value.name] = child.node_result_to_strawberry_type(node_result.copy_with(value))
else:
kwargs[child.value.name] = None
else:
kwargs[child.value.name] = node_result.value(child)
if (attribute := self._model_instance_attribute()):
kwargs[attribute] = node_result.model
return self.strawberry_type(**kwargs)
def query_result_to_strawberry_type(self, results: QueryResult[Any]) -> Sequence[T]:
"""Recursively constructs a sequence of Strawberry type instances from a query result.
Args:
results: The query result to convert.
Returns:
A sequence of Strawberry type instances.
"""
return [self.node_result_to_strawberry_type(node_result) for node_result in results]
def aggregation_query_result_to_strawberry_type(self, results: QueryResult[Any]) -> T:
"""Recursively constructs a Strawberry type instance from an aggregation query result.
Args:
results: The query result to convert.
Returns:
A Strawberry type instance.
"""
kwargs: dict[str, Any] = {}
nodes_child = self.find_child(lambda child: child.value.name == NODES_KEY)
aggregations_child = self.find_child(lambda child: child.value.name == AGGREGATIONS_KEY)
kwargs[NODES_KEY], kwargs[AGGREGATIONS_KEY] = ([], None)
if isinstance(nodes_child, StrawberryQueryNode):
kwargs[NODES_KEY] = [nodes_child.node_result_to_strawberry_type(node_results) for node_results in results]
if isinstance(aggregations_child, StrawberryQueryNode):
aggregations = self._default_type_kwargs(aggregations_child)
aggregations.update({child.value.name: child.computed_value(child, results) for child in aggregations_child.children if isinstance(child, StrawberryQueryNode)})
kwargs[AGGREGATIONS_KEY] = aggregations_child.strawberry_type(**aggregations)
return self.strawberry_type(**kwargs)
|
@dataclass(eq=False, repr=False)
class StrawberryQueryNode(QueryNode, Generic[T]):
@property
def strawberry_type(self) -> type[T]:
pass
def _model_instance_attribute(self) -> Optional[str]:
pass
@classmethod
def _default_type_kwargs(cls, node: StrawberryQueryNode[Any]) -> dict[str, Any]:
pass
def computed_value(self, node: QueryNodeType, result: Union[NodeResult[Any], QueryResult[Any]]) -> T:
pass
def node_result_to_strawberry_type(self, node_result: NodeResult[Any]) -> T:
pass
def query_result_to_strawberry_type(self, results: QueryResult[Any]) -> Sequence[T]:
'''Recursively constructs a sequence of Strawberry type instances from a query result.
Args:
results: The query result to convert.
Returns:
A sequence of Strawberry type instances.
'''
pass
def aggregation_query_result_to_strawberry_type(self, results: QueryResult[Any]) -> T:
'''Recursively constructs a Strawberry type instance from an aggregation query result.
Args:
results: The query result to convert.
Returns:
A Strawberry type instance.
'''
pass
| 11
| 2
| 12
| 1
| 9
| 2
| 3
| 0.17
| 2
| 9
| 2
| 0
| 6
| 0
| 7
| 52
| 91
| 10
| 69
| 22
| 59
| 12
| 48
| 19
| 40
| 8
| 3
| 3
| 19
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.