0 def execute(self, Actions, State): \"\"\" Execute","None self.RemainingLifetime = RemainingLifetime def __copy__(self): Duplicate = ProjectileClass(self.ID, self.Owner, self.Health) Duplicate.Position =","occupied by unit Position: location of unit Orientation: as the name says VisibleRange:","return None def overlaps(self, Unit): MyOccupiedSpace = set([ (self.Position[0]+x, self.Position[1]+y, self.Position[2]) for x","Created on Tue Dec 15 09:49:47 2020 @author: james.z.hare \"\"\" from src.UnitModule import","memo.get(self, Default) if Exists is not Default: return Exists Duplicate = ProjectileClass(deepcopy(self.ID, memo),","`Actions`. \"\"\" NewState = deepcopy(State) Changes = [] for Action in Actions: ActionResult","actions \"\"\" return self.ActionOptions def observe(self, Unit): if Unit.ID == self.ID: return Unit","deepcopy(self.Attack, memo) Duplicate.RemainingLifetime = deepcopy(self.RemainingLifetime, memo) memo[self] = Duplicate return Duplicate def possibleActions(self,","return self.ActionOptions def observe(self, Unit): if Unit.ID == self.ID: return Unit return None","if Unit.ID == self.ID: return Unit return None def overlaps(self, Unit): MyOccupiedSpace =","Default: return Exists Duplicate = ProjectileClass(deepcopy(self.ID, memo), deepcopy(self.Owner ,memo), deepcopy(self.Health, memo)) Duplicate.Position =","unit Owner: the player the unit belongs to Health: the health of the","memo) Duplicate.Orientation = deepcopy(self.Orientation, memo) Duplicate.Attack = deepcopy(self.Attack, memo) Duplicate.RemainingLifetime = deepcopy(self.RemainingLifetime, memo)","---------- ID: a unique identifier of this unit Owner: the player the unit","actions - `observe(Unit)` to observe units located within VisibleRange - `overlaps(Unit)` to identify","advance from copy import deepcopy import math class ProjectileClass(UnitClass): \"\"\" The Projectile Class","def execute(self, Actions, State): \"\"\" Execute `Actions` on `State`. Parameters ---------- Actions :","Health, Extent=(1,1)) self.Actions = { \"advance\": lambda x: advance(self, x) } self.ActionOptions =","identify legal actions - `observe(Unit)` to observe units located within VisibleRange - `overlaps(Unit)`","Default) if Exists is not Default: return Exists Duplicate = ProjectileClass(deepcopy(self.ID, memo), deepcopy(self.Owner","legal actions - `observe(Unit)` to observe units located within VisibleRange - `overlaps(Unit)` to","`__deepcopy__(memo)` to make deep copies - `possibleActions(State)` to identify legal actions - `observe(Unit)`","= Duplicate return Duplicate def possibleActions(self, State): \"\"\" Identifies the set of feasible","\"\"\" Identifies the set of feasible actions given the board size and position","= set([ (Unit.Position[0]+x, Unit.Position[1]+y, Unit.Position[2]) for x in range(Unit.Extent[0]) for y in range(Unit.Extent[1])","the unit overlaps with another unit - `execute(Action, State)` to execute the action","State)` to execute the action Attributes ---------- ID: a unique identifier of this","given the board size and position of the unit Parameters ---------- State: StateClass","set of feasible actions given the board size and position of the unit","self.Attack = None self.RemainingLifetime = RemainingLifetime def __copy__(self): Duplicate = ProjectileClass(self.ID, self.Owner, self.Health)","Duplicate.Orientation = self.Orientation Duplicate.Attack = self.Attack Duplicate.RemainingLifetime = self.RemainingLifetime return Duplicate def __deepcopy__(self,","1 if isinstance(ActionResult, list): Changes += ActionResult else: Changes.append(ActionResult) return Changes # Will","for the missile launcher unit class MissileClass(ProjectileClass): def __init__(self, ID, Owner, Position, Life=1):","`__copy__()` to make shallow copies - `__deepcopy__(memo)` to make deep copies - `possibleActions(State)`","size and position of the unit Parameters ---------- State: StateClass Returns ------- TrueActions:","Exists Duplicate = ProjectileClass(deepcopy(self.ID, memo), deepcopy(self.Owner ,memo), deepcopy(self.Health, memo)) Duplicate.Position = deepcopy(self.Position, memo)","make shallow copies - `__deepcopy__(memo)` to make deep copies - `possibleActions(State)` to identify","State): \"\"\" Execute `Actions` on `State`. Parameters ---------- Actions : list[str] A set","number of turns until the unit is dead \"\"\" def __init__(self, ID, Owner,","within VisibleRange - `overlaps(Unit)` to identify if the unit overlaps with another unit","y in range(self.Extent[1]) ]) #print(Unit) TheirOccupiedSpace = set([ (Unit.Position[0]+x, Unit.Position[1]+y, Unit.Position[2]) for x","the health of the unit Extent: the space occupied by unit Position: location","unit Orientation: as the name says VisibleRange: how far the unit can observe","the projectile for the missile launcher unit class MissileClass(ProjectileClass): def __init__(self, ID, Owner,","unit can observe Actions: dict dictionary of actions common accross all units ActionOptions:","Extent: the space occupied by unit Position: location of unit Orientation: as the","= deepcopy(self.Orientation, memo) Duplicate.Attack = deepcopy(self.Attack, memo) Duplicate.RemainingLifetime = deepcopy(self.RemainingLifetime, memo) memo[self] =","of turns until the unit is dead \"\"\" def __init__(self, ID, Owner, Health,","utf-8 -*- \"\"\" Created on Tue Dec 15 09:49:47 2020 @author: james.z.hare \"\"\"","far the unit can observe Actions: dict dictionary of actions common accross all","that defines the total number of turns until the unit is dead \"\"\"","Duplicate.Position = self.Position Duplicate.Orientation = self.Orientation Duplicate.Attack = self.Attack Duplicate.RemainingLifetime = self.RemainingLifetime return","------- Changes : list Resulting state of executed `Actions`. \"\"\" NewState = deepcopy(State)","ID, Owner, Health, RemainingLifetime=math.inf): UnitClass.__init__(self, ID, Owner, Health, Extent=(1,1)) self.Actions = { \"advance\":","= ProjectileClass(self.ID, self.Owner, self.Health) Duplicate.Position = self.Position Duplicate.Orientation = self.Orientation Duplicate.Attack = self.Attack","unit is dead \"\"\" def __init__(self, ID, Owner, Health, RemainingLifetime=math.inf): UnitClass.__init__(self, ID, Owner,","belongs to Health: the health of the unit Extent: the space occupied by","]) #print(Unit) TheirOccupiedSpace = set([ (Unit.Position[0]+x, Unit.Position[1]+y, Unit.Position[2]) for x in range(Unit.Extent[0]) for","]) return len(MyOccupiedSpace.intersection(TheirOccupiedSpace))>0 def execute(self, Actions, State): \"\"\" Execute `Actions` on `State`. Parameters","the missile launcher unit class MissileClass(ProjectileClass): def __init__(self, ID, Owner, Position, Life=1): ProjectileClass.__init__(self,","in an advance action RemaingLifetime: int that defines the total number of turns","import UnitClass, advance from copy import deepcopy import math class ProjectileClass(UnitClass): \"\"\" The","Default = None Exists = memo.get(self, Default) if Exists is not Default: return","= None Exists = memo.get(self, Default) if Exists is not Default: return Exists","Unit): if Unit.ID == self.ID: return Unit return None def overlaps(self, Unit): MyOccupiedSpace","to Health: the health of the unit Extent: the space occupied by unit","Parameters ---------- Actions : list[str] A set of actions to be performed on","`State`. State : StateClass State on which to inflict actions. Returns ------- Changes","player the unit belongs to Health: the health of the unit Extent: the","The Projectile Class This is a subclass to the UnitClass Virtual Functions -----------------","ID: a unique identifier of this unit Owner: the player the unit belongs","= self.Attack Duplicate.RemainingLifetime = self.RemainingLifetime return Duplicate def __deepcopy__(self, memo): Default = None","common accross all units ActionOptions: list of list of action options. Attack: int","= ( ( \"advance\", ), ) self.Attack = None self.RemainingLifetime = RemainingLifetime def","= deepcopy(self.RemainingLifetime, memo) memo[self] = Duplicate return Duplicate def possibleActions(self, State): \"\"\" Identifies","to make shallow copies - `__deepcopy__(memo)` to make deep copies - `possibleActions(State)` to","the player the unit belongs to Health: the health of the unit Extent:","Will be used as the projectile for the missile launcher unit class MissileClass(ProjectileClass):","name says VisibleRange: how far the unit can observe Actions: dict dictionary of","y in range(Unit.Extent[1]) ]) return len(MyOccupiedSpace.intersection(TheirOccupiedSpace))>0 def execute(self, Actions, State): \"\"\" Execute `Actions`","Actions, State): \"\"\" Execute `Actions` on `State`. Parameters ---------- Actions : list[str] A","copies - `__deepcopy__(memo)` to make deep copies - `possibleActions(State)` to identify legal actions","= deepcopy(State) Changes = [] for Action in Actions: ActionResult = self.Actions[Action](NewState) ActionResult[1].RemainingLifetime","Actions: ActionResult = self.Actions[Action](NewState) ActionResult[1].RemainingLifetime -= 1 if isinstance(ActionResult, list): Changes += ActionResult","board size and position of the unit Parameters ---------- State: StateClass Returns -------","if isinstance(ActionResult, list): Changes += ActionResult else: Changes.append(ActionResult) return Changes # Will be","\"\"\" NewState = deepcopy(State) Changes = [] for Action in Actions: ActionResult =","list of the feasible actions \"\"\" return self.ActionOptions def observe(self, Unit): if Unit.ID","located within VisibleRange - `overlaps(Unit)` to identify if the unit overlaps with another","unit class MissileClass(ProjectileClass): def __init__(self, ID, Owner, Position, Life=1): ProjectileClass.__init__(self, ID, Owner, Positon=Position,","= ProjectileClass(deepcopy(self.ID, memo), deepcopy(self.Owner ,memo), deepcopy(self.Health, memo)) Duplicate.Position = deepcopy(self.Position, memo) Duplicate.Orientation =","from src.UnitModule import UnitClass, advance from copy import deepcopy import math class ProjectileClass(UnitClass):","be performed on `State`. State : StateClass State on which to inflict actions.","coding: utf-8 -*- \"\"\" Created on Tue Dec 15 09:49:47 2020 @author: james.z.hare","Duplicate.Orientation = deepcopy(self.Orientation, memo) Duplicate.Attack = deepcopy(self.Attack, memo) Duplicate.RemainingLifetime = deepcopy(self.RemainingLifetime, memo) memo[self]","health of the unit Extent: the space occupied by unit Position: location of","james.z.hare \"\"\" from src.UnitModule import UnitClass, advance from copy import deepcopy import math","Changes # Will be used as the projectile for the missile launcher unit","list[str] A set of actions to be performed on `State`. State : StateClass","another unit - `execute(Action, State)` to execute the action Attributes ---------- ID: a","# Will be used as the projectile for the missile launcher unit class","list of list of action options. Attack: int that defines whether the unit","This is a subclass to the UnitClass Virtual Functions ----------------- - `__copy__()` to","A list of the feasible actions \"\"\" return self.ActionOptions def observe(self, Unit): if","Changes : list Resulting state of executed `Actions`. \"\"\" NewState = deepcopy(State) Changes","Orientation: as the name says VisibleRange: how far the unit can observe Actions:","`State`. Parameters ---------- Actions : list[str] A set of actions to be performed","------- TrueActions: list[str] A list of the feasible actions \"\"\" return self.ActionOptions def","of actions to be performed on `State`. State : StateClass State on which","= RemainingLifetime def __copy__(self): Duplicate = ProjectileClass(self.ID, self.Owner, self.Health) Duplicate.Position = self.Position Duplicate.Orientation","and position of the unit Parameters ---------- State: StateClass Returns ------- TrueActions: list[str]","memo)) Duplicate.Position = deepcopy(self.Position, memo) Duplicate.Orientation = deepcopy(self.Orientation, memo) Duplicate.Attack = deepcopy(self.Attack, memo)","set([ (Unit.Position[0]+x, Unit.Position[1]+y, Unit.Position[2]) for x in range(Unit.Extent[0]) for y in range(Unit.Extent[1]) ])","as the name says VisibleRange: how far the unit can observe Actions: dict","import math class ProjectileClass(UnitClass): \"\"\" The Projectile Class This is a subclass to","the feasible actions \"\"\" return self.ActionOptions def observe(self, Unit): if Unit.ID == self.ID:","memo), deepcopy(self.Owner ,memo), deepcopy(self.Health, memo)) Duplicate.Position = deepcopy(self.Position, memo) Duplicate.Orientation = deepcopy(self.Orientation, memo)","int that defines whether the unit is attacking in an advance action RemaingLifetime:","execute the action Attributes ---------- ID: a unique identifier of this unit Owner:","on `State`. Parameters ---------- Actions : list[str] A set of actions to be","15 09:49:47 2020 @author: james.z.hare \"\"\" from src.UnitModule import UnitClass, advance from copy","= self.RemainingLifetime return Duplicate def __deepcopy__(self, memo): Default = None Exists = memo.get(self,","= memo.get(self, Default) if Exists is not Default: return Exists Duplicate = ProjectileClass(deepcopy(self.ID,","observe units located within VisibleRange - `overlaps(Unit)` to identify if the unit overlaps","the UnitClass Virtual Functions ----------------- - `__copy__()` to make shallow copies - `__deepcopy__(memo)`","the unit can observe Actions: dict dictionary of actions common accross all units","subclass to the UnitClass Virtual Functions ----------------- - `__copy__()` to make shallow copies","deep copies - `possibleActions(State)` to identify legal actions - `observe(Unit)` to observe units","math class ProjectileClass(UnitClass): \"\"\" The Projectile Class This is a subclass to the","action Attributes ---------- ID: a unique identifier of this unit Owner: the player","the unit belongs to Health: the health of the unit Extent: the space","__init__(self, ID, Owner, Health, RemainingLifetime=math.inf): UnitClass.__init__(self, ID, Owner, Health, Extent=(1,1)) self.Actions = {","not Default: return Exists Duplicate = ProjectileClass(deepcopy(self.ID, memo), deepcopy(self.Owner ,memo), deepcopy(self.Health, memo)) Duplicate.Position","State on which to inflict actions. Returns ------- Changes : list Resulting state","Duplicate.Position = deepcopy(self.Position, memo) Duplicate.Orientation = deepcopy(self.Orientation, memo) Duplicate.Attack = deepcopy(self.Attack, memo) Duplicate.RemainingLifetime","memo) memo[self] = Duplicate return Duplicate def possibleActions(self, State): \"\"\" Identifies the set","lambda x: advance(self, x) } self.ActionOptions = ( ( \"advance\", ), ) self.Attack","def __deepcopy__(self, memo): Default = None Exists = memo.get(self, Default) if Exists is","of this unit Owner: the player the unit belongs to Health: the health","`Actions` on `State`. Parameters ---------- Actions : list[str] A set of actions to","to execute the action Attributes ---------- ID: a unique identifier of this unit","is dead \"\"\" def __init__(self, ID, Owner, Health, RemainingLifetime=math.inf): UnitClass.__init__(self, ID, Owner, Health,","how far the unit can observe Actions: dict dictionary of actions common accross","in Actions: ActionResult = self.Actions[Action](NewState) ActionResult[1].RemainingLifetime -= 1 if isinstance(ActionResult, list): Changes +=","self.RemainingLifetime = RemainingLifetime def __copy__(self): Duplicate = ProjectileClass(self.ID, self.Owner, self.Health) Duplicate.Position = self.Position","MyOccupiedSpace = set([ (self.Position[0]+x, self.Position[1]+y, self.Position[2]) for x in range(self.Extent[0]) for y in","09:49:47 2020 @author: james.z.hare \"\"\" from src.UnitModule import UnitClass, advance from copy import","ActionOptions: list of list of action options. Attack: int that defines whether the","A set of actions to be performed on `State`. State : StateClass State","self.ActionOptions = ( ( \"advance\", ), ) self.Attack = None self.RemainingLifetime = RemainingLifetime","self.Position Duplicate.Orientation = self.Orientation Duplicate.Attack = self.Attack Duplicate.RemainingLifetime = self.RemainingLifetime return Duplicate def","Exists = memo.get(self, Default) if Exists is not Default: return Exists Duplicate =","self.Actions[Action](NewState) ActionResult[1].RemainingLifetime -= 1 if isinstance(ActionResult, list): Changes += ActionResult else: Changes.append(ActionResult) return","position of the unit Parameters ---------- State: StateClass Returns ------- TrueActions: list[str] A","range(Unit.Extent[0]) for y in range(Unit.Extent[1]) ]) return len(MyOccupiedSpace.intersection(TheirOccupiedSpace))>0 def execute(self, Actions, State): \"\"\"","missile launcher unit class MissileClass(ProjectileClass): def __init__(self, ID, Owner, Position, Life=1): ProjectileClass.__init__(self, ID,","range(self.Extent[1]) ]) #print(Unit) TheirOccupiedSpace = set([ (Unit.Position[0]+x, Unit.Position[1]+y, Unit.Position[2]) for x in range(Unit.Extent[0])","an advance action RemaingLifetime: int that defines the total number of turns until","dictionary of actions common accross all units ActionOptions: list of list of action","StateClass Returns ------- TrueActions: list[str] A list of the feasible actions \"\"\" return","Identifies the set of feasible actions given the board size and position of","+= ActionResult else: Changes.append(ActionResult) return Changes # Will be used as the projectile","x: advance(self, x) } self.ActionOptions = ( ( \"advance\", ), ) self.Attack =","Returns ------- TrueActions: list[str] A list of the feasible actions \"\"\" return self.ActionOptions","as the projectile for the missile launcher unit class MissileClass(ProjectileClass): def __init__(self, ID,","make deep copies - `possibleActions(State)` to identify legal actions - `observe(Unit)` to observe","self.Actions = { \"advance\": lambda x: advance(self, x) } self.ActionOptions = ( (","of the feasible actions \"\"\" return self.ActionOptions def observe(self, Unit): if Unit.ID ==","class MissileClass(ProjectileClass): def __init__(self, ID, Owner, Position, Life=1): ProjectileClass.__init__(self, ID, Owner, Positon=Position, Life=Life)","None Exists = memo.get(self, Default) if Exists is not Default: return Exists Duplicate","self.ActionOptions def observe(self, Unit): if Unit.ID == self.ID: return Unit return None def","unit - `execute(Action, State)` to execute the action Attributes ---------- ID: a unique","self.Owner, self.Health) Duplicate.Position = self.Position Duplicate.Orientation = self.Orientation Duplicate.Attack = self.Attack Duplicate.RemainingLifetime =","\"\"\" def __init__(self, ID, Owner, Health, RemainingLifetime=math.inf): UnitClass.__init__(self, ID, Owner, Health, Extent=(1,1)) self.Actions","Duplicate def __deepcopy__(self, memo): Default = None Exists = memo.get(self, Default) if Exists","ActionResult = self.Actions[Action](NewState) ActionResult[1].RemainingLifetime -= 1 if isinstance(ActionResult, list): Changes += ActionResult else:","self.Position[1]+y, self.Position[2]) for x in range(self.Extent[0]) for y in range(self.Extent[1]) ]) #print(Unit) TheirOccupiedSpace","launcher unit class MissileClass(ProjectileClass): def __init__(self, ID, Owner, Position, Life=1): ProjectileClass.__init__(self, ID, Owner,","advance action RemaingLifetime: int that defines the total number of turns until the","performed on `State`. State : StateClass State on which to inflict actions. Returns","Class This is a subclass to the UnitClass Virtual Functions ----------------- - `__copy__()`","`overlaps(Unit)` to identify if the unit overlaps with another unit - `execute(Action, State)`","of unit Orientation: as the name says VisibleRange: how far the unit can","Actions: dict dictionary of actions common accross all units ActionOptions: list of list","Owner, Health, RemainingLifetime=math.inf): UnitClass.__init__(self, ID, Owner, Health, Extent=(1,1)) self.Actions = { \"advance\": lambda","ID, Owner, Health, Extent=(1,1)) self.Actions = { \"advance\": lambda x: advance(self, x) }","all units ActionOptions: list of list of action options. Attack: int that defines","self.Health) Duplicate.Position = self.Position Duplicate.Orientation = self.Orientation Duplicate.Attack = self.Attack Duplicate.RemainingLifetime = self.RemainingLifetime","ProjectileClass(deepcopy(self.ID, memo), deepcopy(self.Owner ,memo), deepcopy(self.Health, memo)) Duplicate.Position = deepcopy(self.Position, memo) Duplicate.Orientation = deepcopy(self.Orientation,","unit Parameters ---------- State: StateClass Returns ------- TrueActions: list[str] A list of the","= deepcopy(self.Attack, memo) Duplicate.RemainingLifetime = deepcopy(self.RemainingLifetime, memo) memo[self] = Duplicate return Duplicate def","= { \"advance\": lambda x: advance(self, x) } self.ActionOptions = ( ( \"advance\",","def possibleActions(self, State): \"\"\" Identifies the set of feasible actions given the board","src.UnitModule import UnitClass, advance from copy import deepcopy import math class ProjectileClass(UnitClass): \"\"\"","int that defines the total number of turns until the unit is dead","\"advance\": lambda x: advance(self, x) } self.ActionOptions = ( ( \"advance\", ), )","feasible actions \"\"\" return self.ActionOptions def observe(self, Unit): if Unit.ID == self.ID: return","Attributes ---------- ID: a unique identifier of this unit Owner: the player the","attacking in an advance action RemaingLifetime: int that defines the total number of","deepcopy(self.Orientation, memo) Duplicate.Attack = deepcopy(self.Attack, memo) Duplicate.RemainingLifetime = deepcopy(self.RemainingLifetime, memo) memo[self] = Duplicate","advance(self, x) } self.ActionOptions = ( ( \"advance\", ), ) self.Attack = None","for x in range(Unit.Extent[0]) for y in range(Unit.Extent[1]) ]) return len(MyOccupiedSpace.intersection(TheirOccupiedSpace))>0 def execute(self,","unique identifier of this unit Owner: the player the unit belongs to Health:","units located within VisibleRange - `overlaps(Unit)` to identify if the unit overlaps with","options. Attack: int that defines whether the unit is attacking in an advance","action RemaingLifetime: int that defines the total number of turns until the unit","Actions : list[str] A set of actions to be performed on `State`. State","dead \"\"\" def __init__(self, ID, Owner, Health, RemainingLifetime=math.inf): UnitClass.__init__(self, ID, Owner, Health, Extent=(1,1))","on `State`. State : StateClass State on which to inflict actions. Returns -------","# -*- coding: utf-8 -*- \"\"\" Created on Tue Dec 15 09:49:47 2020","StateClass State on which to inflict actions. Returns ------- Changes : list Resulting","RemainingLifetime def __copy__(self): Duplicate = ProjectileClass(self.ID, self.Owner, self.Health) Duplicate.Position = self.Position Duplicate.Orientation =","__deepcopy__(self, memo): Default = None Exists = memo.get(self, Default) if Exists is not","feasible actions given the board size and position of the unit Parameters ----------","until the unit is dead \"\"\" def __init__(self, ID, Owner, Health, RemainingLifetime=math.inf): UnitClass.__init__(self,","len(MyOccupiedSpace.intersection(TheirOccupiedSpace))>0 def execute(self, Actions, State): \"\"\" Execute `Actions` on `State`. Parameters ---------- Actions","to identify legal actions - `observe(Unit)` to observe units located within VisibleRange -","x in range(self.Extent[0]) for y in range(self.Extent[1]) ]) #print(Unit) TheirOccupiedSpace = set([ (Unit.Position[0]+x,","---------- State: StateClass Returns ------- TrueActions: list[str] A list of the feasible actions","Health, RemainingLifetime=math.inf): UnitClass.__init__(self, ID, Owner, Health, Extent=(1,1)) self.Actions = { \"advance\": lambda x:","import deepcopy import math class ProjectileClass(UnitClass): \"\"\" The Projectile Class This is a","to identify if the unit overlaps with another unit - `execute(Action, State)` to","projectile for the missile launcher unit class MissileClass(ProjectileClass): def __init__(self, ID, Owner, Position,","is not Default: return Exists Duplicate = ProjectileClass(deepcopy(self.ID, memo), deepcopy(self.Owner ,memo), deepcopy(self.Health, memo))","used as the projectile for the missile launcher unit class MissileClass(ProjectileClass): def __init__(self,","for y in range(self.Extent[1]) ]) #print(Unit) TheirOccupiedSpace = set([ (Unit.Position[0]+x, Unit.Position[1]+y, Unit.Position[2]) for","= [] for Action in Actions: ActionResult = self.Actions[Action](NewState) ActionResult[1].RemainingLifetime -= 1 if","- `__copy__()` to make shallow copies - `__deepcopy__(memo)` to make deep copies -","x) } self.ActionOptions = ( ( \"advance\", ), ) self.Attack = None self.RemainingLifetime","the board size and position of the unit Parameters ---------- State: StateClass Returns","return Duplicate def possibleActions(self, State): \"\"\" Identifies the set of feasible actions given","Owner, Health, Extent=(1,1)) self.Actions = { \"advance\": lambda x: advance(self, x) } self.ActionOptions","range(self.Extent[0]) for y in range(self.Extent[1]) ]) #print(Unit) TheirOccupiedSpace = set([ (Unit.Position[0]+x, Unit.Position[1]+y, Unit.Position[2])","@author: james.z.hare \"\"\" from src.UnitModule import UnitClass, advance from copy import deepcopy import","self.ID: return Unit return None def overlaps(self, Unit): MyOccupiedSpace = set([ (self.Position[0]+x, self.Position[1]+y,","def __init__(self, ID, Owner, Health, RemainingLifetime=math.inf): UnitClass.__init__(self, ID, Owner, Health, Extent=(1,1)) self.Actions =","the name says VisibleRange: how far the unit can observe Actions: dict dictionary","Exists is not Default: return Exists Duplicate = ProjectileClass(deepcopy(self.ID, memo), deepcopy(self.Owner ,memo), deepcopy(self.Health,","= self.Actions[Action](NewState) ActionResult[1].RemainingLifetime -= 1 if isinstance(ActionResult, list): Changes += ActionResult else: Changes.append(ActionResult)","Duplicate def possibleActions(self, State): \"\"\" Identifies the set of feasible actions given the","to be performed on `State`. State : StateClass State on which to inflict","Dec 15 09:49:47 2020 @author: james.z.hare \"\"\" from src.UnitModule import UnitClass, advance from","the unit Parameters ---------- State: StateClass Returns ------- TrueActions: list[str] A list of","NewState = deepcopy(State) Changes = [] for Action in Actions: ActionResult = self.Actions[Action](NewState)","of the unit Parameters ---------- State: StateClass Returns ------- TrueActions: list[str] A list","\"\"\" from src.UnitModule import UnitClass, advance from copy import deepcopy import math class","in range(self.Extent[1]) ]) #print(Unit) TheirOccupiedSpace = set([ (Unit.Position[0]+x, Unit.Position[1]+y, Unit.Position[2]) for x in","VisibleRange: how far the unit can observe Actions: dict dictionary of actions common","-= 1 if isinstance(ActionResult, list): Changes += ActionResult else: Changes.append(ActionResult) return Changes #","unit is attacking in an advance action RemaingLifetime: int that defines the total","return Changes # Will be used as the projectile for the missile launcher","Duplicate = ProjectileClass(self.ID, self.Owner, self.Health) Duplicate.Position = self.Position Duplicate.Orientation = self.Orientation Duplicate.Attack =","possibleActions(self, State): \"\"\" Identifies the set of feasible actions given the board size","overlaps with another unit - `execute(Action, State)` to execute the action Attributes ----------","observe(self, Unit): if Unit.ID == self.ID: return Unit return None def overlaps(self, Unit):","in range(Unit.Extent[0]) for y in range(Unit.Extent[1]) ]) return len(MyOccupiedSpace.intersection(TheirOccupiedSpace))>0 def execute(self, Actions, State):","Virtual Functions ----------------- - `__copy__()` to make shallow copies - `__deepcopy__(memo)` to make","\"\"\" Execute `Actions` on `State`. Parameters ---------- Actions : list[str] A set of","executed `Actions`. \"\"\" NewState = deepcopy(State) Changes = [] for Action in Actions:","list[str] A list of the feasible actions \"\"\" return self.ActionOptions def observe(self, Unit):","dict dictionary of actions common accross all units ActionOptions: list of list of","a subclass to the UnitClass Virtual Functions ----------------- - `__copy__()` to make shallow","identifier of this unit Owner: the player the unit belongs to Health: the","accross all units ActionOptions: list of list of action options. Attack: int that","the action Attributes ---------- ID: a unique identifier of this unit Owner: the","State : StateClass State on which to inflict actions. Returns ------- Changes :","Action in Actions: ActionResult = self.Actions[Action](NewState) ActionResult[1].RemainingLifetime -= 1 if isinstance(ActionResult, list): Changes","deepcopy(self.Owner ,memo), deepcopy(self.Health, memo)) Duplicate.Position = deepcopy(self.Position, memo) Duplicate.Orientation = deepcopy(self.Orientation, memo) Duplicate.Attack","= deepcopy(self.Position, memo) Duplicate.Orientation = deepcopy(self.Orientation, memo) Duplicate.Attack = deepcopy(self.Attack, memo) Duplicate.RemainingLifetime =","the unit is attacking in an advance action RemaingLifetime: int that defines the","unit Position: location of unit Orientation: as the name says VisibleRange: how far","deepcopy(self.Health, memo)) Duplicate.Position = deepcopy(self.Position, memo) Duplicate.Orientation = deepcopy(self.Orientation, memo) Duplicate.Attack = deepcopy(self.Attack,","defines the total number of turns until the unit is dead \"\"\" def","return Exists Duplicate = ProjectileClass(deepcopy(self.ID, memo), deepcopy(self.Owner ,memo), deepcopy(self.Health, memo)) Duplicate.Position = deepcopy(self.Position,","\"\"\" The Projectile Class This is a subclass to the UnitClass Virtual Functions","says VisibleRange: how far the unit can observe Actions: dict dictionary of actions","Unit return None def overlaps(self, Unit): MyOccupiedSpace = set([ (self.Position[0]+x, self.Position[1]+y, self.Position[2]) for","if the unit overlaps with another unit - `execute(Action, State)` to execute the","Unit): MyOccupiedSpace = set([ (self.Position[0]+x, self.Position[1]+y, self.Position[2]) for x in range(self.Extent[0]) for y","deepcopy(State) Changes = [] for Action in Actions: ActionResult = self.Actions[Action](NewState) ActionResult[1].RemainingLifetime -=","deepcopy(self.Position, memo) Duplicate.Orientation = deepcopy(self.Orientation, memo) Duplicate.Attack = deepcopy(self.Attack, memo) Duplicate.RemainingLifetime = deepcopy(self.RemainingLifetime,","for Action in Actions: ActionResult = self.Actions[Action](NewState) ActionResult[1].RemainingLifetime -= 1 if isinstance(ActionResult, list):","memo) Duplicate.Attack = deepcopy(self.Attack, memo) Duplicate.RemainingLifetime = deepcopy(self.RemainingLifetime, memo) memo[self] = Duplicate return","if Exists is not Default: return Exists Duplicate = ProjectileClass(deepcopy(self.ID, memo), deepcopy(self.Owner ,memo),","the set of feasible actions given the board size and position of the","unit Extent: the space occupied by unit Position: location of unit Orientation: as","-*- \"\"\" Created on Tue Dec 15 09:49:47 2020 @author: james.z.hare \"\"\" from","range(Unit.Extent[1]) ]) return len(MyOccupiedSpace.intersection(TheirOccupiedSpace))>0 def execute(self, Actions, State): \"\"\" Execute `Actions` on `State`.","} self.ActionOptions = ( ( \"advance\", ), ) self.Attack = None self.RemainingLifetime =","Duplicate return Duplicate def possibleActions(self, State): \"\"\" Identifies the set of feasible actions","units ActionOptions: list of list of action options. Attack: int that defines whether","set([ (self.Position[0]+x, self.Position[1]+y, self.Position[2]) for x in range(self.Extent[0]) for y in range(self.Extent[1]) ])","Duplicate.Attack = self.Attack Duplicate.RemainingLifetime = self.RemainingLifetime return Duplicate def __deepcopy__(self, memo): Default =","the total number of turns until the unit is dead \"\"\" def __init__(self,","Changes = [] for Action in Actions: ActionResult = self.Actions[Action](NewState) ActionResult[1].RemainingLifetime -= 1","Unit.ID == self.ID: return Unit return None def overlaps(self, Unit): MyOccupiedSpace = set([","execute(self, Actions, State): \"\"\" Execute `Actions` on `State`. Parameters ---------- Actions : list[str]","for x in range(self.Extent[0]) for y in range(self.Extent[1]) ]) #print(Unit) TheirOccupiedSpace = set([","ActionResult else: Changes.append(ActionResult) return Changes # Will be used as the projectile for","- `__deepcopy__(memo)` to make deep copies - `possibleActions(State)` to identify legal actions -","( \"advance\", ), ) self.Attack = None self.RemainingLifetime = RemainingLifetime def __copy__(self): Duplicate","action options. Attack: int that defines whether the unit is attacking in an","with another unit - `execute(Action, State)` to execute the action Attributes ---------- ID:",",memo), deepcopy(self.Health, memo)) Duplicate.Position = deepcopy(self.Position, memo) Duplicate.Orientation = deepcopy(self.Orientation, memo) Duplicate.Attack =",") self.Attack = None self.RemainingLifetime = RemainingLifetime def __copy__(self): Duplicate = ProjectileClass(self.ID, self.Owner,","-*- coding: utf-8 -*- \"\"\" Created on Tue Dec 15 09:49:47 2020 @author:","----------------- - `__copy__()` to make shallow copies - `__deepcopy__(memo)` to make deep copies","set of actions to be performed on `State`. State : StateClass State on","deepcopy(self.RemainingLifetime, memo) memo[self] = Duplicate return Duplicate def possibleActions(self, State): \"\"\" Identifies the","self.RemainingLifetime return Duplicate def __deepcopy__(self, memo): Default = None Exists = memo.get(self, Default)","Extent=(1,1)) self.Actions = { \"advance\": lambda x: advance(self, x) } self.ActionOptions = (","Tue Dec 15 09:49:47 2020 @author: james.z.hare \"\"\" from src.UnitModule import UnitClass, advance","`possibleActions(State)` to identify legal actions - `observe(Unit)` to observe units located within VisibleRange","inflict actions. Returns ------- Changes : list Resulting state of executed `Actions`. \"\"\"","actions common accross all units ActionOptions: list of list of action options. Attack:","to the UnitClass Virtual Functions ----------------- - `__copy__()` to make shallow copies -","unit overlaps with another unit - `execute(Action, State)` to execute the action Attributes","UnitClass Virtual Functions ----------------- - `__copy__()` to make shallow copies - `__deepcopy__(memo)` to","Duplicate = ProjectileClass(deepcopy(self.ID, memo), deepcopy(self.Owner ,memo), deepcopy(self.Health, memo)) Duplicate.Position = deepcopy(self.Position, memo) Duplicate.Orientation","Duplicate.RemainingLifetime = self.RemainingLifetime return Duplicate def __deepcopy__(self, memo): Default = None Exists =","of the unit Extent: the space occupied by unit Position: location of unit","else: Changes.append(ActionResult) return Changes # Will be used as the projectile for the","observe Actions: dict dictionary of actions common accross all units ActionOptions: list of","Duplicate.RemainingLifetime = deepcopy(self.RemainingLifetime, memo) memo[self] = Duplicate return Duplicate def possibleActions(self, State): \"\"\"","by unit Position: location of unit Orientation: as the name says VisibleRange: how","x in range(Unit.Extent[0]) for y in range(Unit.Extent[1]) ]) return len(MyOccupiedSpace.intersection(TheirOccupiedSpace))>0 def execute(self, Actions,","Position: location of unit Orientation: as the name says VisibleRange: how far the","def observe(self, Unit): if Unit.ID == self.ID: return Unit return None def overlaps(self,","State): \"\"\" Identifies the set of feasible actions given the board size and","- `execute(Action, State)` to execute the action Attributes ---------- ID: a unique identifier","TheirOccupiedSpace = set([ (Unit.Position[0]+x, Unit.Position[1]+y, Unit.Position[2]) for x in range(Unit.Extent[0]) for y in","location of unit Orientation: as the name says VisibleRange: how far the unit","ActionResult[1].RemainingLifetime -= 1 if isinstance(ActionResult, list): Changes += ActionResult else: Changes.append(ActionResult) return Changes","#print(Unit) TheirOccupiedSpace = set([ (Unit.Position[0]+x, Unit.Position[1]+y, Unit.Position[2]) for x in range(Unit.Extent[0]) for y","RemainingLifetime=math.inf): UnitClass.__init__(self, ID, Owner, Health, Extent=(1,1)) self.Actions = { \"advance\": lambda x: advance(self,",": list[str] A set of actions to be performed on `State`. State :","list Resulting state of executed `Actions`. \"\"\" NewState = deepcopy(State) Changes = []","of feasible actions given the board size and position of the unit Parameters","overlaps(self, Unit): MyOccupiedSpace = set([ (self.Position[0]+x, self.Position[1]+y, self.Position[2]) for x in range(self.Extent[0]) for","memo[self] = Duplicate return Duplicate def possibleActions(self, State): \"\"\" Identifies the set of","None def overlaps(self, Unit): MyOccupiedSpace = set([ (self.Position[0]+x, self.Position[1]+y, self.Position[2]) for x in","class ProjectileClass(UnitClass): \"\"\" The Projectile Class This is a subclass to the UnitClass","unit belongs to Health: the health of the unit Extent: the space occupied","state of executed `Actions`. \"\"\" NewState = deepcopy(State) Changes = [] for Action","can observe Actions: dict dictionary of actions common accross all units ActionOptions: list","Parameters ---------- State: StateClass Returns ------- TrueActions: list[str] A list of the feasible","self.Position[2]) for x in range(self.Extent[0]) for y in range(self.Extent[1]) ]) #print(Unit) TheirOccupiedSpace =","of list of action options. Attack: int that defines whether the unit is","to inflict actions. Returns ------- Changes : list Resulting state of executed `Actions`.","), ) self.Attack = None self.RemainingLifetime = RemainingLifetime def __copy__(self): Duplicate = ProjectileClass(self.ID,","Health: the health of the unit Extent: the space occupied by unit Position:","== self.ID: return Unit return None def overlaps(self, Unit): MyOccupiedSpace = set([ (self.Position[0]+x,","total number of turns until the unit is dead \"\"\" def __init__(self, ID,","actions given the board size and position of the unit Parameters ---------- State:","Owner: the player the unit belongs to Health: the health of the unit","Unit.Position[2]) for x in range(Unit.Extent[0]) for y in range(Unit.Extent[1]) ]) return len(MyOccupiedSpace.intersection(TheirOccupiedSpace))>0 def","is a subclass to the UnitClass Virtual Functions ----------------- - `__copy__()` to make","of action options. Attack: int that defines whether the unit is attacking in","= self.Position Duplicate.Orientation = self.Orientation Duplicate.Attack = self.Attack Duplicate.RemainingLifetime = self.RemainingLifetime return Duplicate","in range(Unit.Extent[1]) ]) return len(MyOccupiedSpace.intersection(TheirOccupiedSpace))>0 def execute(self, Actions, State): \"\"\" Execute `Actions` on","return Duplicate def __deepcopy__(self, memo): Default = None Exists = memo.get(self, Default) if","VisibleRange - `overlaps(Unit)` to identify if the unit overlaps with another unit -","on Tue Dec 15 09:49:47 2020 @author: james.z.hare \"\"\" from src.UnitModule import UnitClass,","def __copy__(self): Duplicate = ProjectileClass(self.ID, self.Owner, self.Health) Duplicate.Position = self.Position Duplicate.Orientation = self.Orientation","( ( \"advance\", ), ) self.Attack = None self.RemainingLifetime = RemainingLifetime def __copy__(self):","the unit Extent: the space occupied by unit Position: location of unit Orientation:","def overlaps(self, Unit): MyOccupiedSpace = set([ (self.Position[0]+x, self.Position[1]+y, self.Position[2]) for x in range(self.Extent[0])","which to inflict actions. Returns ------- Changes : list Resulting state of executed","of executed `Actions`. \"\"\" NewState = deepcopy(State) Changes = [] for Action in",": StateClass State on which to inflict actions. Returns ------- Changes : list","to observe units located within VisibleRange - `overlaps(Unit)` to identify if the unit","`observe(Unit)` to observe units located within VisibleRange - `overlaps(Unit)` to identify if the","= None self.RemainingLifetime = RemainingLifetime def __copy__(self): Duplicate = ProjectileClass(self.ID, self.Owner, self.Health) Duplicate.Position","shallow copies - `__deepcopy__(memo)` to make deep copies - `possibleActions(State)` to identify legal","be used as the projectile for the missile launcher unit class MissileClass(ProjectileClass): def","turns until the unit is dead \"\"\" def __init__(self, ID, Owner, Health, RemainingLifetime=math.inf):","\"advance\", ), ) self.Attack = None self.RemainingLifetime = RemainingLifetime def __copy__(self): Duplicate =","isinstance(ActionResult, list): Changes += ActionResult else: Changes.append(ActionResult) return Changes # Will be used","return Unit return None def overlaps(self, Unit): MyOccupiedSpace = set([ (self.Position[0]+x, self.Position[1]+y, self.Position[2])","Execute `Actions` on `State`. Parameters ---------- Actions : list[str] A set of actions","that defines whether the unit is attacking in an advance action RemaingLifetime: int","---------- Actions : list[str] A set of actions to be performed on `State`.","Projectile Class This is a subclass to the UnitClass Virtual Functions ----------------- -","on which to inflict actions. Returns ------- Changes : list Resulting state of",": list Resulting state of executed `Actions`. \"\"\" NewState = deepcopy(State) Changes =","Functions ----------------- - `__copy__()` to make shallow copies - `__deepcopy__(memo)` to make deep","__copy__(self): Duplicate = ProjectileClass(self.ID, self.Owner, self.Health) Duplicate.Position = self.Position Duplicate.Orientation = self.Orientation Duplicate.Attack","- `overlaps(Unit)` to identify if the unit overlaps with another unit - `execute(Action,","(Unit.Position[0]+x, Unit.Position[1]+y, Unit.Position[2]) for x in range(Unit.Extent[0]) for y in range(Unit.Extent[1]) ]) return","self.Attack Duplicate.RemainingLifetime = self.RemainingLifetime return Duplicate def __deepcopy__(self, memo): Default = None Exists","space occupied by unit Position: location of unit Orientation: as the name says","Changes.append(ActionResult) return Changes # Will be used as the projectile for the missile","2020 @author: james.z.hare \"\"\" from src.UnitModule import UnitClass, advance from copy import deepcopy","in range(self.Extent[0]) for y in range(self.Extent[1]) ]) #print(Unit) TheirOccupiedSpace = set([ (Unit.Position[0]+x, Unit.Position[1]+y,","ProjectileClass(self.ID, self.Owner, self.Health) Duplicate.Position = self.Position Duplicate.Orientation = self.Orientation Duplicate.Attack = self.Attack Duplicate.RemainingLifetime","list): Changes += ActionResult else: Changes.append(ActionResult) return Changes # Will be used as","`execute(Action, State)` to execute the action Attributes ---------- ID: a unique identifier of","the unit is dead \"\"\" def __init__(self, ID, Owner, Health, RemainingLifetime=math.inf): UnitClass.__init__(self, ID,","(self.Position[0]+x, self.Position[1]+y, self.Position[2]) for x in range(self.Extent[0]) for y in range(self.Extent[1]) ]) #print(Unit)"],"string":"[\n \"the space occupied by unit Position: location of unit Orientation: as the name\",\n \"= self.Orientation Duplicate.Attack = self.Attack Duplicate.RemainingLifetime = self.RemainingLifetime return Duplicate def __deepcopy__(self, memo):\",\n \"memo): Default = None Exists = memo.get(self, Default) if Exists is not Default:\",\n \"UnitClass.__init__(self, ID, Owner, Health, Extent=(1,1)) self.Actions = { \\\"advance\\\": lambda x: advance(self, x)\",\n \"\\\"\\\"\\\" Created on Tue Dec 15 09:49:47 2020 @author: james.z.hare \\\"\\\"\\\" from src.UnitModule\",\n \"Attack: int that defines whether the unit is attacking in an advance action\",\n \"self.Orientation Duplicate.Attack = self.Attack Duplicate.RemainingLifetime = self.RemainingLifetime return Duplicate def __deepcopy__(self, memo): Default\",\n \"from copy import deepcopy import math class ProjectileClass(UnitClass): \\\"\\\"\\\" The Projectile Class This\",\n \"this unit Owner: the player the unit belongs to Health: the health of\",\n \"list of action options. Attack: int that defines whether the unit is attacking\",\n \"return len(MyOccupiedSpace.intersection(TheirOccupiedSpace))>0 def execute(self, Actions, State): \\\"\\\"\\\" Execute `Actions` on `State`. Parameters ----------\",\n \"memo) Duplicate.RemainingLifetime = deepcopy(self.RemainingLifetime, memo) memo[self] = Duplicate return Duplicate def possibleActions(self, State):\",\n \"actions to be performed on `State`. State : StateClass State on which to\",\n \"- `possibleActions(State)` to identify legal actions - `observe(Unit)` to observe units located within\",\n \"deepcopy import math class ProjectileClass(UnitClass): \\\"\\\"\\\" The Projectile Class This is a subclass\",\n \"defines whether the unit is attacking in an advance action RemaingLifetime: int that\",\n \"actions. Returns ------- Changes : list Resulting state of executed `Actions`. \\\"\\\"\\\" NewState\",\n \"Changes += ActionResult else: Changes.append(ActionResult) return Changes # Will be used as the\",\n \"identify if the unit overlaps with another unit - `execute(Action, State)` to execute\",\n \"\\\"\\\"\\\" return self.ActionOptions def observe(self, Unit): if Unit.ID == self.ID: return Unit return\",\n \"of actions common accross all units ActionOptions: list of list of action options.\",\n \"Unit.Position[1]+y, Unit.Position[2]) for x in range(Unit.Extent[0]) for y in range(Unit.Extent[1]) ]) return len(MyOccupiedSpace.intersection(TheirOccupiedSpace))>0\",\n \"copy import deepcopy import math class ProjectileClass(UnitClass): \\\"\\\"\\\" The Projectile Class This is\",\n \"- `observe(Unit)` to observe units located within VisibleRange - `overlaps(Unit)` to identify if\",\n \"Duplicate.Attack = deepcopy(self.Attack, memo) Duplicate.RemainingLifetime = deepcopy(self.RemainingLifetime, memo) memo[self] = Duplicate return Duplicate\",\n \"copies - `possibleActions(State)` to identify legal actions - `observe(Unit)` to observe units located\",\n \"TrueActions: list[str] A list of the feasible actions \\\"\\\"\\\" return self.ActionOptions def observe(self,\",\n \"UnitClass, advance from copy import deepcopy import math class ProjectileClass(UnitClass): \\\"\\\"\\\" The Projectile\",\n \"a unique identifier of this unit Owner: the player the unit belongs to\",\n \"whether the unit is attacking in an advance action RemaingLifetime: int that defines\",\n \"ProjectileClass(UnitClass): \\\"\\\"\\\" The Projectile Class This is a subclass to the UnitClass Virtual\",\n \"RemaingLifetime: int that defines the total number of turns until the unit is\",\n \"Returns ------- Changes : list Resulting state of executed `Actions`. \\\"\\\"\\\" NewState =\",\n \"to make deep copies - `possibleActions(State)` to identify legal actions - `observe(Unit)` to\",\n \"is attacking in an advance action RemaingLifetime: int that defines the total number\",\n \"{ \\\"advance\\\": lambda x: advance(self, x) } self.ActionOptions = ( ( \\\"advance\\\", ),\",\n \"State: StateClass Returns ------- TrueActions: list[str] A list of the feasible actions \\\"\\\"\\\"\",\n \"= set([ (self.Position[0]+x, self.Position[1]+y, self.Position[2]) for x in range(self.Extent[0]) for y in range(self.Extent[1])\",\n \"[] for Action in Actions: ActionResult = self.Actions[Action](NewState) ActionResult[1].RemainingLifetime -= 1 if isinstance(ActionResult,\",\n \"Resulting state of executed `Actions`. \\\"\\\"\\\" NewState = deepcopy(State) Changes = [] for\",\n \"for y in range(Unit.Extent[1]) ]) return len(MyOccupiedSpace.intersection(TheirOccupiedSpace))>0 def execute(self, Actions, State): \\\"\\\"\\\" Execute\",\n \"None self.RemainingLifetime = RemainingLifetime def __copy__(self): Duplicate = ProjectileClass(self.ID, self.Owner, self.Health) Duplicate.Position =\",\n \"occupied by unit Position: location of unit Orientation: as the name says VisibleRange:\",\n \"return None def overlaps(self, Unit): MyOccupiedSpace = set([ (self.Position[0]+x, self.Position[1]+y, self.Position[2]) for x\",\n \"Created on Tue Dec 15 09:49:47 2020 @author: james.z.hare \\\"\\\"\\\" from src.UnitModule import\",\n \"memo.get(self, Default) if Exists is not Default: return Exists Duplicate = ProjectileClass(deepcopy(self.ID, memo),\",\n \"`Actions`. \\\"\\\"\\\" NewState = deepcopy(State) Changes = [] for Action in Actions: ActionResult\",\n \"actions \\\"\\\"\\\" return self.ActionOptions def observe(self, Unit): if Unit.ID == self.ID: return Unit\",\n \"deepcopy(self.Attack, memo) Duplicate.RemainingLifetime = deepcopy(self.RemainingLifetime, memo) memo[self] = Duplicate return Duplicate def possibleActions(self,\",\n \"return self.ActionOptions def observe(self, Unit): if Unit.ID == self.ID: return Unit return None\",\n \"if Unit.ID == self.ID: return Unit return None def overlaps(self, Unit): MyOccupiedSpace =\",\n \"Default: return Exists Duplicate = ProjectileClass(deepcopy(self.ID, memo), deepcopy(self.Owner ,memo), deepcopy(self.Health, memo)) Duplicate.Position =\",\n \"unit Owner: the player the unit belongs to Health: the health of the\",\n \"memo) Duplicate.Orientation = deepcopy(self.Orientation, memo) Duplicate.Attack = deepcopy(self.Attack, memo) Duplicate.RemainingLifetime = deepcopy(self.RemainingLifetime, memo)\",\n \"---------- ID: a unique identifier of this unit Owner: the player the unit\",\n \"actions - `observe(Unit)` to observe units located within VisibleRange - `overlaps(Unit)` to identify\",\n \"advance from copy import deepcopy import math class ProjectileClass(UnitClass): \\\"\\\"\\\" The Projectile Class\",\n \"def execute(self, Actions, State): \\\"\\\"\\\" Execute `Actions` on `State`. Parameters ---------- Actions :\",\n \"Health, Extent=(1,1)) self.Actions = { \\\"advance\\\": lambda x: advance(self, x) } self.ActionOptions =\",\n \"identify legal actions - `observe(Unit)` to observe units located within VisibleRange - `overlaps(Unit)`\",\n \"Default) if Exists is not Default: return Exists Duplicate = ProjectileClass(deepcopy(self.ID, memo), deepcopy(self.Owner\",\n \"legal actions - `observe(Unit)` to observe units located within VisibleRange - `overlaps(Unit)` to\",\n \"`__deepcopy__(memo)` to make deep copies - `possibleActions(State)` to identify legal actions - `observe(Unit)`\",\n \"= Duplicate return Duplicate def possibleActions(self, State): \\\"\\\"\\\" Identifies the set of feasible\",\n \"\\\"\\\"\\\" Identifies the set of feasible actions given the board size and position\",\n \"= set([ (Unit.Position[0]+x, Unit.Position[1]+y, Unit.Position[2]) for x in range(Unit.Extent[0]) for y in range(Unit.Extent[1])\",\n \"the unit overlaps with another unit - `execute(Action, State)` to execute the action\",\n \"State)` to execute the action Attributes ---------- ID: a unique identifier of this\",\n \"given the board size and position of the unit Parameters ---------- State: StateClass\",\n \"set of feasible actions given the board size and position of the unit\",\n \"self.Attack = None self.RemainingLifetime = RemainingLifetime def __copy__(self): Duplicate = ProjectileClass(self.ID, self.Owner, self.Health)\",\n \"Duplicate.Orientation = self.Orientation Duplicate.Attack = self.Attack Duplicate.RemainingLifetime = self.RemainingLifetime return Duplicate def __deepcopy__(self,\",\n \"1 if isinstance(ActionResult, list): Changes += ActionResult else: Changes.append(ActionResult) return Changes # Will\",\n \"for the missile launcher unit class MissileClass(ProjectileClass): def __init__(self, ID, Owner, Position, Life=1):\",\n \"`__copy__()` to make shallow copies - `__deepcopy__(memo)` to make deep copies - `possibleActions(State)`\",\n \"size and position of the unit Parameters ---------- State: StateClass Returns ------- TrueActions:\",\n \"Exists Duplicate = ProjectileClass(deepcopy(self.ID, memo), deepcopy(self.Owner ,memo), deepcopy(self.Health, memo)) Duplicate.Position = deepcopy(self.Position, memo)\",\n \"make shallow copies - `__deepcopy__(memo)` to make deep copies - `possibleActions(State)` to identify\",\n \"State): \\\"\\\"\\\" Execute `Actions` on `State`. Parameters ---------- Actions : list[str] A set\",\n \"number of turns until the unit is dead \\\"\\\"\\\" def __init__(self, ID, Owner,\",\n \"within VisibleRange - `overlaps(Unit)` to identify if the unit overlaps with another unit\",\n \"y in range(self.Extent[1]) ]) #print(Unit) TheirOccupiedSpace = set([ (Unit.Position[0]+x, Unit.Position[1]+y, Unit.Position[2]) for x\",\n \"the health of the unit Extent: the space occupied by unit Position: location\",\n \"unit Orientation: as the name says VisibleRange: how far the unit can observe\",\n \"the projectile for the missile launcher unit class MissileClass(ProjectileClass): def __init__(self, ID, Owner,\",\n \"unit can observe Actions: dict dictionary of actions common accross all units ActionOptions:\",\n \"Extent: the space occupied by unit Position: location of unit Orientation: as the\",\n \"= deepcopy(self.Orientation, memo) Duplicate.Attack = deepcopy(self.Attack, memo) Duplicate.RemainingLifetime = deepcopy(self.RemainingLifetime, memo) memo[self] =\",\n \"of turns until the unit is dead \\\"\\\"\\\" def __init__(self, ID, Owner, Health,\",\n \"utf-8 -*- \\\"\\\"\\\" Created on Tue Dec 15 09:49:47 2020 @author: james.z.hare \\\"\\\"\\\"\",\n \"far the unit can observe Actions: dict dictionary of actions common accross all\",\n \"that defines the total number of turns until the unit is dead \\\"\\\"\\\"\",\n \"Duplicate.Position = self.Position Duplicate.Orientation = self.Orientation Duplicate.Attack = self.Attack Duplicate.RemainingLifetime = self.RemainingLifetime return\",\n \"------- Changes : list Resulting state of executed `Actions`. \\\"\\\"\\\" NewState = deepcopy(State)\",\n \"ID, Owner, Health, RemainingLifetime=math.inf): UnitClass.__init__(self, ID, Owner, Health, Extent=(1,1)) self.Actions = { \\\"advance\\\":\",\n \"= ProjectileClass(self.ID, self.Owner, self.Health) Duplicate.Position = self.Position Duplicate.Orientation = self.Orientation Duplicate.Attack = self.Attack\",\n \"unit is dead \\\"\\\"\\\" def __init__(self, ID, Owner, Health, RemainingLifetime=math.inf): UnitClass.__init__(self, ID, Owner,\",\n \"belongs to Health: the health of the unit Extent: the space occupied by\",\n \"]) #print(Unit) TheirOccupiedSpace = set([ (Unit.Position[0]+x, Unit.Position[1]+y, Unit.Position[2]) for x in range(Unit.Extent[0]) for\",\n \"]) return len(MyOccupiedSpace.intersection(TheirOccupiedSpace))>0 def execute(self, Actions, State): \\\"\\\"\\\" Execute `Actions` on `State`. Parameters\",\n \"the missile launcher unit class MissileClass(ProjectileClass): def __init__(self, ID, Owner, Position, Life=1): ProjectileClass.__init__(self,\",\n \"in an advance action RemaingLifetime: int that defines the total number of turns\",\n \"import UnitClass, advance from copy import deepcopy import math class ProjectileClass(UnitClass): \\\"\\\"\\\" The\",\n \"Default = None Exists = memo.get(self, Default) if Exists is not Default: return\",\n \"= None Exists = memo.get(self, Default) if Exists is not Default: return Exists\",\n \"Unit): if Unit.ID == self.ID: return Unit return None def overlaps(self, Unit): MyOccupiedSpace\",\n \"to Health: the health of the unit Extent: the space occupied by unit\",\n \"Parameters ---------- Actions : list[str] A set of actions to be performed on\",\n \"`State`. State : StateClass State on which to inflict actions. Returns ------- Changes\",\n \"player the unit belongs to Health: the health of the unit Extent: the\",\n \"The Projectile Class This is a subclass to the UnitClass Virtual Functions -----------------\",\n \"ID: a unique identifier of this unit Owner: the player the unit belongs\",\n \"= self.Attack Duplicate.RemainingLifetime = self.RemainingLifetime return Duplicate def __deepcopy__(self, memo): Default = None\",\n \"common accross all units ActionOptions: list of list of action options. Attack: int\",\n \"= ( ( \\\"advance\\\", ), ) self.Attack = None self.RemainingLifetime = RemainingLifetime def\",\n \"= deepcopy(self.RemainingLifetime, memo) memo[self] = Duplicate return Duplicate def possibleActions(self, State): \\\"\\\"\\\" Identifies\",\n \"to make shallow copies - `__deepcopy__(memo)` to make deep copies - `possibleActions(State)` to\",\n \"the player the unit belongs to Health: the health of the unit Extent:\",\n \"Will be used as the projectile for the missile launcher unit class MissileClass(ProjectileClass):\",\n \"name says VisibleRange: how far the unit can observe Actions: dict dictionary of\",\n \"y in range(Unit.Extent[1]) ]) return len(MyOccupiedSpace.intersection(TheirOccupiedSpace))>0 def execute(self, Actions, State): \\\"\\\"\\\" Execute `Actions`\",\n \"Actions, State): \\\"\\\"\\\" Execute `Actions` on `State`. Parameters ---------- Actions : list[str] A\",\n \"copies - `__deepcopy__(memo)` to make deep copies - `possibleActions(State)` to identify legal actions\",\n \"= deepcopy(State) Changes = [] for Action in Actions: ActionResult = self.Actions[Action](NewState) ActionResult[1].RemainingLifetime\",\n \"Actions: ActionResult = self.Actions[Action](NewState) ActionResult[1].RemainingLifetime -= 1 if isinstance(ActionResult, list): Changes += ActionResult\",\n \"board size and position of the unit Parameters ---------- State: StateClass Returns -------\",\n \"if isinstance(ActionResult, list): Changes += ActionResult else: Changes.append(ActionResult) return Changes # Will be\",\n \"\\\"\\\"\\\" NewState = deepcopy(State) Changes = [] for Action in Actions: ActionResult =\",\n \"list of the feasible actions \\\"\\\"\\\" return self.ActionOptions def observe(self, Unit): if Unit.ID\",\n \"located within VisibleRange - `overlaps(Unit)` to identify if the unit overlaps with another\",\n \"unit class MissileClass(ProjectileClass): def __init__(self, ID, Owner, Position, Life=1): ProjectileClass.__init__(self, ID, Owner, Positon=Position,\",\n \"= ProjectileClass(deepcopy(self.ID, memo), deepcopy(self.Owner ,memo), deepcopy(self.Health, memo)) Duplicate.Position = deepcopy(self.Position, memo) Duplicate.Orientation =\",\n \"from src.UnitModule import UnitClass, advance from copy import deepcopy import math class ProjectileClass(UnitClass):\",\n \"be performed on `State`. State : StateClass State on which to inflict actions.\",\n \"coding: utf-8 -*- \\\"\\\"\\\" Created on Tue Dec 15 09:49:47 2020 @author: james.z.hare\",\n \"Duplicate.Orientation = deepcopy(self.Orientation, memo) Duplicate.Attack = deepcopy(self.Attack, memo) Duplicate.RemainingLifetime = deepcopy(self.RemainingLifetime, memo) memo[self]\",\n \"health of the unit Extent: the space occupied by unit Position: location of\",\n \"james.z.hare \\\"\\\"\\\" from src.UnitModule import UnitClass, advance from copy import deepcopy import math\",\n \"Changes # Will be used as the projectile for the missile launcher unit\",\n \"list[str] A set of actions to be performed on `State`. State : StateClass\",\n \"another unit - `execute(Action, State)` to execute the action Attributes ---------- ID: a\",\n \"# Will be used as the projectile for the missile launcher unit class\",\n \"list of list of action options. Attack: int that defines whether the unit\",\n \"This is a subclass to the UnitClass Virtual Functions ----------------- - `__copy__()` to\",\n \"A list of the feasible actions \\\"\\\"\\\" return self.ActionOptions def observe(self, Unit): if\",\n \"Changes : list Resulting state of executed `Actions`. \\\"\\\"\\\" NewState = deepcopy(State) Changes\",\n \"Orientation: as the name says VisibleRange: how far the unit can observe Actions:\",\n \"`State`. Parameters ---------- Actions : list[str] A set of actions to be performed\",\n \"------- TrueActions: list[str] A list of the feasible actions \\\"\\\"\\\" return self.ActionOptions def\",\n \"of actions to be performed on `State`. State : StateClass State on which\",\n \"= RemainingLifetime def __copy__(self): Duplicate = ProjectileClass(self.ID, self.Owner, self.Health) Duplicate.Position = self.Position Duplicate.Orientation\",\n \"and position of the unit Parameters ---------- State: StateClass Returns ------- TrueActions: list[str]\",\n \"memo)) Duplicate.Position = deepcopy(self.Position, memo) Duplicate.Orientation = deepcopy(self.Orientation, memo) Duplicate.Attack = deepcopy(self.Attack, memo)\",\n \"set([ (Unit.Position[0]+x, Unit.Position[1]+y, Unit.Position[2]) for x in range(Unit.Extent[0]) for y in range(Unit.Extent[1]) ])\",\n \"as the name says VisibleRange: how far the unit can observe Actions: dict\",\n \"import math class ProjectileClass(UnitClass): \\\"\\\"\\\" The Projectile Class This is a subclass to\",\n \"the feasible actions \\\"\\\"\\\" return self.ActionOptions def observe(self, Unit): if Unit.ID == self.ID:\",\n \"memo), deepcopy(self.Owner ,memo), deepcopy(self.Health, memo)) Duplicate.Position = deepcopy(self.Position, memo) Duplicate.Orientation = deepcopy(self.Orientation, memo)\",\n \"int that defines whether the unit is attacking in an advance action RemaingLifetime:\",\n \"execute the action Attributes ---------- ID: a unique identifier of this unit Owner:\",\n \"on `State`. Parameters ---------- Actions : list[str] A set of actions to be\",\n \"15 09:49:47 2020 @author: james.z.hare \\\"\\\"\\\" from src.UnitModule import UnitClass, advance from copy\",\n \"= self.RemainingLifetime return Duplicate def __deepcopy__(self, memo): Default = None Exists = memo.get(self,\",\n \"= memo.get(self, Default) if Exists is not Default: return Exists Duplicate = ProjectileClass(deepcopy(self.ID,\",\n \"observe units located within VisibleRange - `overlaps(Unit)` to identify if the unit overlaps\",\n \"the UnitClass Virtual Functions ----------------- - `__copy__()` to make shallow copies - `__deepcopy__(memo)`\",\n \"the unit can observe Actions: dict dictionary of actions common accross all units\",\n \"subclass to the UnitClass Virtual Functions ----------------- - `__copy__()` to make shallow copies\",\n \"deep copies - `possibleActions(State)` to identify legal actions - `observe(Unit)` to observe units\",\n \"math class ProjectileClass(UnitClass): \\\"\\\"\\\" The Projectile Class This is a subclass to the\",\n \"action Attributes ---------- ID: a unique identifier of this unit Owner: the player\",\n \"the unit belongs to Health: the health of the unit Extent: the space\",\n \"__init__(self, ID, Owner, Health, RemainingLifetime=math.inf): UnitClass.__init__(self, ID, Owner, Health, Extent=(1,1)) self.Actions = {\",\n \"not Default: return Exists Duplicate = ProjectileClass(deepcopy(self.ID, memo), deepcopy(self.Owner ,memo), deepcopy(self.Health, memo)) Duplicate.Position\",\n \"State on which to inflict actions. Returns ------- Changes : list Resulting state\",\n \"Duplicate.Position = deepcopy(self.Position, memo) Duplicate.Orientation = deepcopy(self.Orientation, memo) Duplicate.Attack = deepcopy(self.Attack, memo) Duplicate.RemainingLifetime\",\n \"memo) memo[self] = Duplicate return Duplicate def possibleActions(self, State): \\\"\\\"\\\" Identifies the set\",\n \"lambda x: advance(self, x) } self.ActionOptions = ( ( \\\"advance\\\", ), ) self.Attack\",\n \"def __deepcopy__(self, memo): Default = None Exists = memo.get(self, Default) if Exists is\",\n \"of this unit Owner: the player the unit belongs to Health: the health\",\n \"`Actions` on `State`. Parameters ---------- Actions : list[str] A set of actions to\",\n \"to execute the action Attributes ---------- ID: a unique identifier of this unit\",\n \"is dead \\\"\\\"\\\" def __init__(self, ID, Owner, Health, RemainingLifetime=math.inf): UnitClass.__init__(self, ID, Owner, Health,\",\n \"how far the unit can observe Actions: dict dictionary of actions common accross\",\n \"in Actions: ActionResult = self.Actions[Action](NewState) ActionResult[1].RemainingLifetime -= 1 if isinstance(ActionResult, list): Changes +=\",\n \"self.RemainingLifetime = RemainingLifetime def __copy__(self): Duplicate = ProjectileClass(self.ID, self.Owner, self.Health) Duplicate.Position = self.Position\",\n \"MyOccupiedSpace = set([ (self.Position[0]+x, self.Position[1]+y, self.Position[2]) for x in range(self.Extent[0]) for y in\",\n \"09:49:47 2020 @author: james.z.hare \\\"\\\"\\\" from src.UnitModule import UnitClass, advance from copy import\",\n \"ActionOptions: list of list of action options. Attack: int that defines whether the\",\n \"A set of actions to be performed on `State`. State : StateClass State\",\n \"self.ActionOptions = ( ( \\\"advance\\\", ), ) self.Attack = None self.RemainingLifetime = RemainingLifetime\",\n \"self.Position Duplicate.Orientation = self.Orientation Duplicate.Attack = self.Attack Duplicate.RemainingLifetime = self.RemainingLifetime return Duplicate def\",\n \"Exists = memo.get(self, Default) if Exists is not Default: return Exists Duplicate =\",\n \"self.Actions[Action](NewState) ActionResult[1].RemainingLifetime -= 1 if isinstance(ActionResult, list): Changes += ActionResult else: Changes.append(ActionResult) return\",\n \"position of the unit Parameters ---------- State: StateClass Returns ------- TrueActions: list[str] A\",\n \"range(Unit.Extent[0]) for y in range(Unit.Extent[1]) ]) return len(MyOccupiedSpace.intersection(TheirOccupiedSpace))>0 def execute(self, Actions, State): \\\"\\\"\\\"\",\n \"missile launcher unit class MissileClass(ProjectileClass): def __init__(self, ID, Owner, Position, Life=1): ProjectileClass.__init__(self, ID,\",\n \"range(self.Extent[1]) ]) #print(Unit) TheirOccupiedSpace = set([ (Unit.Position[0]+x, Unit.Position[1]+y, Unit.Position[2]) for x in range(Unit.Extent[0])\",\n \"an advance action RemaingLifetime: int that defines the total number of turns until\",\n \"dictionary of actions common accross all units ActionOptions: list of list of action\",\n \"StateClass Returns ------- TrueActions: list[str] A list of the feasible actions \\\"\\\"\\\" return\",\n \"Identifies the set of feasible actions given the board size and position of\",\n \"+= ActionResult else: Changes.append(ActionResult) return Changes # Will be used as the projectile\",\n \"x: advance(self, x) } self.ActionOptions = ( ( \\\"advance\\\", ), ) self.Attack =\",\n \"Returns ------- TrueActions: list[str] A list of the feasible actions \\\"\\\"\\\" return self.ActionOptions\",\n \"as the projectile for the missile launcher unit class MissileClass(ProjectileClass): def __init__(self, ID,\",\n \"make deep copies - `possibleActions(State)` to identify legal actions - `observe(Unit)` to observe\",\n \"self.Actions = { \\\"advance\\\": lambda x: advance(self, x) } self.ActionOptions = ( (\",\n \"of the feasible actions \\\"\\\"\\\" return self.ActionOptions def observe(self, Unit): if Unit.ID ==\",\n \"class MissileClass(ProjectileClass): def __init__(self, ID, Owner, Position, Life=1): ProjectileClass.__init__(self, ID, Owner, Positon=Position, Life=Life)\",\n \"None Exists = memo.get(self, Default) if Exists is not Default: return Exists Duplicate\",\n \"self.ActionOptions def observe(self, Unit): if Unit.ID == self.ID: return Unit return None def\",\n \"unit - `execute(Action, State)` to execute the action Attributes ---------- ID: a unique\",\n \"self.Owner, self.Health) Duplicate.Position = self.Position Duplicate.Orientation = self.Orientation Duplicate.Attack = self.Attack Duplicate.RemainingLifetime =\",\n \"\\\"\\\"\\\" def __init__(self, ID, Owner, Health, RemainingLifetime=math.inf): UnitClass.__init__(self, ID, Owner, Health, Extent=(1,1)) self.Actions\",\n \"Duplicate def __deepcopy__(self, memo): Default = None Exists = memo.get(self, Default) if Exists\",\n \"ActionResult = self.Actions[Action](NewState) ActionResult[1].RemainingLifetime -= 1 if isinstance(ActionResult, list): Changes += ActionResult else:\",\n \"self.Position[1]+y, self.Position[2]) for x in range(self.Extent[0]) for y in range(self.Extent[1]) ]) #print(Unit) TheirOccupiedSpace\",\n \"launcher unit class MissileClass(ProjectileClass): def __init__(self, ID, Owner, Position, Life=1): ProjectileClass.__init__(self, ID, Owner,\",\n \"advance action RemaingLifetime: int that defines the total number of turns until the\",\n \"performed on `State`. State : StateClass State on which to inflict actions. Returns\",\n \"Class This is a subclass to the UnitClass Virtual Functions ----------------- - `__copy__()`\",\n \"`overlaps(Unit)` to identify if the unit overlaps with another unit - `execute(Action, State)`\",\n \"of unit Orientation: as the name says VisibleRange: how far the unit can\",\n \"Actions: dict dictionary of actions common accross all units ActionOptions: list of list\",\n \"Owner, Health, RemainingLifetime=math.inf): UnitClass.__init__(self, ID, Owner, Health, Extent=(1,1)) self.Actions = { \\\"advance\\\": lambda\",\n \"ID, Owner, Health, Extent=(1,1)) self.Actions = { \\\"advance\\\": lambda x: advance(self, x) }\",\n \"all units ActionOptions: list of list of action options. Attack: int that defines\",\n \"self.Health) Duplicate.Position = self.Position Duplicate.Orientation = self.Orientation Duplicate.Attack = self.Attack Duplicate.RemainingLifetime = self.RemainingLifetime\",\n \"ProjectileClass(deepcopy(self.ID, memo), deepcopy(self.Owner ,memo), deepcopy(self.Health, memo)) Duplicate.Position = deepcopy(self.Position, memo) Duplicate.Orientation = deepcopy(self.Orientation,\",\n \"unit Parameters ---------- State: StateClass Returns ------- TrueActions: list[str] A list of the\",\n \"= deepcopy(self.Attack, memo) Duplicate.RemainingLifetime = deepcopy(self.RemainingLifetime, memo) memo[self] = Duplicate return Duplicate def\",\n \"= { \\\"advance\\\": lambda x: advance(self, x) } self.ActionOptions = ( ( \\\"advance\\\",\",\n \"def possibleActions(self, State): \\\"\\\"\\\" Identifies the set of feasible actions given the board\",\n \"src.UnitModule import UnitClass, advance from copy import deepcopy import math class ProjectileClass(UnitClass): \\\"\\\"\\\"\",\n \"int that defines the total number of turns until the unit is dead\",\n \"\\\"advance\\\": lambda x: advance(self, x) } self.ActionOptions = ( ( \\\"advance\\\", ), )\",\n \"feasible actions \\\"\\\"\\\" return self.ActionOptions def observe(self, Unit): if Unit.ID == self.ID: return\",\n \"Attributes ---------- ID: a unique identifier of this unit Owner: the player the\",\n \"attacking in an advance action RemaingLifetime: int that defines the total number of\",\n \"deepcopy(self.Orientation, memo) Duplicate.Attack = deepcopy(self.Attack, memo) Duplicate.RemainingLifetime = deepcopy(self.RemainingLifetime, memo) memo[self] = Duplicate\",\n \"advance(self, x) } self.ActionOptions = ( ( \\\"advance\\\", ), ) self.Attack = None\",\n \"for x in range(Unit.Extent[0]) for y in range(Unit.Extent[1]) ]) return len(MyOccupiedSpace.intersection(TheirOccupiedSpace))>0 def execute(self,\",\n \"unique identifier of this unit Owner: the player the unit belongs to Health:\",\n \"units located within VisibleRange - `overlaps(Unit)` to identify if the unit overlaps with\",\n \"options. Attack: int that defines whether the unit is attacking in an advance\",\n \"action RemaingLifetime: int that defines the total number of turns until the unit\",\n \"Actions : list[str] A set of actions to be performed on `State`. State\",\n \"dead \\\"\\\"\\\" def __init__(self, ID, Owner, Health, RemainingLifetime=math.inf): UnitClass.__init__(self, ID, Owner, Health, Extent=(1,1))\",\n \"on `State`. State : StateClass State on which to inflict actions. Returns -------\",\n \"# -*- coding: utf-8 -*- \\\"\\\"\\\" Created on Tue Dec 15 09:49:47 2020\",\n \"StateClass State on which to inflict actions. Returns ------- Changes : list Resulting\",\n \"RemainingLifetime def __copy__(self): Duplicate = ProjectileClass(self.ID, self.Owner, self.Health) Duplicate.Position = self.Position Duplicate.Orientation =\",\n \"__deepcopy__(self, memo): Default = None Exists = memo.get(self, Default) if Exists is not\",\n \"feasible actions given the board size and position of the unit Parameters ----------\",\n \"until the unit is dead \\\"\\\"\\\" def __init__(self, ID, Owner, Health, RemainingLifetime=math.inf): UnitClass.__init__(self,\",\n \"len(MyOccupiedSpace.intersection(TheirOccupiedSpace))>0 def execute(self, Actions, State): \\\"\\\"\\\" Execute `Actions` on `State`. Parameters ---------- Actions\",\n \"to identify legal actions - `observe(Unit)` to observe units located within VisibleRange -\",\n \"x in range(self.Extent[0]) for y in range(self.Extent[1]) ]) #print(Unit) TheirOccupiedSpace = set([ (Unit.Position[0]+x,\",\n \"---------- State: StateClass Returns ------- TrueActions: list[str] A list of the feasible actions\",\n \"Health, RemainingLifetime=math.inf): UnitClass.__init__(self, ID, Owner, Health, Extent=(1,1)) self.Actions = { \\\"advance\\\": lambda x:\",\n \"import deepcopy import math class ProjectileClass(UnitClass): \\\"\\\"\\\" The Projectile Class This is a\",\n \"to identify if the unit overlaps with another unit - `execute(Action, State)` to\",\n \"projectile for the missile launcher unit class MissileClass(ProjectileClass): def __init__(self, ID, Owner, Position,\",\n \"is not Default: return Exists Duplicate = ProjectileClass(deepcopy(self.ID, memo), deepcopy(self.Owner ,memo), deepcopy(self.Health, memo))\",\n \"used as the projectile for the missile launcher unit class MissileClass(ProjectileClass): def __init__(self,\",\n \"for y in range(self.Extent[1]) ]) #print(Unit) TheirOccupiedSpace = set([ (Unit.Position[0]+x, Unit.Position[1]+y, Unit.Position[2]) for\",\n \"= [] for Action in Actions: ActionResult = self.Actions[Action](NewState) ActionResult[1].RemainingLifetime -= 1 if\",\n \"- `__copy__()` to make shallow copies - `__deepcopy__(memo)` to make deep copies -\",\n \"x) } self.ActionOptions = ( ( \\\"advance\\\", ), ) self.Attack = None self.RemainingLifetime\",\n \"the board size and position of the unit Parameters ---------- State: StateClass Returns\",\n \"return Duplicate def possibleActions(self, State): \\\"\\\"\\\" Identifies the set of feasible actions given\",\n \"Owner, Health, Extent=(1,1)) self.Actions = { \\\"advance\\\": lambda x: advance(self, x) } self.ActionOptions\",\n \"range(self.Extent[0]) for y in range(self.Extent[1]) ]) #print(Unit) TheirOccupiedSpace = set([ (Unit.Position[0]+x, Unit.Position[1]+y, Unit.Position[2])\",\n \"@author: james.z.hare \\\"\\\"\\\" from src.UnitModule import UnitClass, advance from copy import deepcopy import\",\n \"self.ID: return Unit return None def overlaps(self, Unit): MyOccupiedSpace = set([ (self.Position[0]+x, self.Position[1]+y,\",\n \"def __init__(self, ID, Owner, Health, RemainingLifetime=math.inf): UnitClass.__init__(self, ID, Owner, Health, Extent=(1,1)) self.Actions =\",\n \"the name says VisibleRange: how far the unit can observe Actions: dict dictionary\",\n \"Exists is not Default: return Exists Duplicate = ProjectileClass(deepcopy(self.ID, memo), deepcopy(self.Owner ,memo), deepcopy(self.Health,\",\n \"= self.Actions[Action](NewState) ActionResult[1].RemainingLifetime -= 1 if isinstance(ActionResult, list): Changes += ActionResult else: Changes.append(ActionResult)\",\n \"Duplicate def possibleActions(self, State): \\\"\\\"\\\" Identifies the set of feasible actions given the\",\n \"to be performed on `State`. State : StateClass State on which to inflict\",\n \"Dec 15 09:49:47 2020 @author: james.z.hare \\\"\\\"\\\" from src.UnitModule import UnitClass, advance from\",\n \"the unit Parameters ---------- State: StateClass Returns ------- TrueActions: list[str] A list of\",\n \"NewState = deepcopy(State) Changes = [] for Action in Actions: ActionResult = self.Actions[Action](NewState)\",\n \"of the unit Parameters ---------- State: StateClass Returns ------- TrueActions: list[str] A list\",\n \"\\\"\\\"\\\" from src.UnitModule import UnitClass, advance from copy import deepcopy import math class\",\n \"in range(self.Extent[1]) ]) #print(Unit) TheirOccupiedSpace = set([ (Unit.Position[0]+x, Unit.Position[1]+y, Unit.Position[2]) for x in\",\n \"VisibleRange: how far the unit can observe Actions: dict dictionary of actions common\",\n \"-= 1 if isinstance(ActionResult, list): Changes += ActionResult else: Changes.append(ActionResult) return Changes #\",\n \"unit is attacking in an advance action RemaingLifetime: int that defines the total\",\n \"return Changes # Will be used as the projectile for the missile launcher\",\n \"Duplicate = ProjectileClass(self.ID, self.Owner, self.Health) Duplicate.Position = self.Position Duplicate.Orientation = self.Orientation Duplicate.Attack =\",\n \"possibleActions(self, State): \\\"\\\"\\\" Identifies the set of feasible actions given the board size\",\n \"overlaps with another unit - `execute(Action, State)` to execute the action Attributes ----------\",\n \"observe(self, Unit): if Unit.ID == self.ID: return Unit return None def overlaps(self, Unit):\",\n \"in range(Unit.Extent[0]) for y in range(Unit.Extent[1]) ]) return len(MyOccupiedSpace.intersection(TheirOccupiedSpace))>0 def execute(self, Actions, State):\",\n \"Virtual Functions ----------------- - `__copy__()` to make shallow copies - `__deepcopy__(memo)` to make\",\n \"\\\"\\\"\\\" Execute `Actions` on `State`. Parameters ---------- Actions : list[str] A set of\",\n \"executed `Actions`. \\\"\\\"\\\" NewState = deepcopy(State) Changes = [] for Action in Actions:\",\n \"list[str] A list of the feasible actions \\\"\\\"\\\" return self.ActionOptions def observe(self, Unit):\",\n \"dict dictionary of actions common accross all units ActionOptions: list of list of\",\n \"a subclass to the UnitClass Virtual Functions ----------------- - `__copy__()` to make shallow\",\n \"identifier of this unit Owner: the player the unit belongs to Health: the\",\n \"accross all units ActionOptions: list of list of action options. Attack: int that\",\n \"the action Attributes ---------- ID: a unique identifier of this unit Owner: the\",\n \"State : StateClass State on which to inflict actions. Returns ------- Changes :\",\n \"Action in Actions: ActionResult = self.Actions[Action](NewState) ActionResult[1].RemainingLifetime -= 1 if isinstance(ActionResult, list): Changes\",\n \"deepcopy(self.Owner ,memo), deepcopy(self.Health, memo)) Duplicate.Position = deepcopy(self.Position, memo) Duplicate.Orientation = deepcopy(self.Orientation, memo) Duplicate.Attack\",\n \"= deepcopy(self.Position, memo) Duplicate.Orientation = deepcopy(self.Orientation, memo) Duplicate.Attack = deepcopy(self.Attack, memo) Duplicate.RemainingLifetime =\",\n \"the unit is attacking in an advance action RemaingLifetime: int that defines the\",\n \"unit Position: location of unit Orientation: as the name says VisibleRange: how far\",\n \"deepcopy(self.Health, memo)) Duplicate.Position = deepcopy(self.Position, memo) Duplicate.Orientation = deepcopy(self.Orientation, memo) Duplicate.Attack = deepcopy(self.Attack,\",\n \"defines the total number of turns until the unit is dead \\\"\\\"\\\" def\",\n \"return Exists Duplicate = ProjectileClass(deepcopy(self.ID, memo), deepcopy(self.Owner ,memo), deepcopy(self.Health, memo)) Duplicate.Position = deepcopy(self.Position,\",\n \"\\\"\\\"\\\" The Projectile Class This is a subclass to the UnitClass Virtual Functions\",\n \"says VisibleRange: how far the unit can observe Actions: dict dictionary of actions\",\n \"Unit return None def overlaps(self, Unit): MyOccupiedSpace = set([ (self.Position[0]+x, self.Position[1]+y, self.Position[2]) for\",\n \"if the unit overlaps with another unit - `execute(Action, State)` to execute the\",\n \"Unit): MyOccupiedSpace = set([ (self.Position[0]+x, self.Position[1]+y, self.Position[2]) for x in range(self.Extent[0]) for y\",\n \"deepcopy(State) Changes = [] for Action in Actions: ActionResult = self.Actions[Action](NewState) ActionResult[1].RemainingLifetime -=\",\n \"deepcopy(self.Position, memo) Duplicate.Orientation = deepcopy(self.Orientation, memo) Duplicate.Attack = deepcopy(self.Attack, memo) Duplicate.RemainingLifetime = deepcopy(self.RemainingLifetime,\",\n \"for Action in Actions: ActionResult = self.Actions[Action](NewState) ActionResult[1].RemainingLifetime -= 1 if isinstance(ActionResult, list):\",\n \"memo) Duplicate.Attack = deepcopy(self.Attack, memo) Duplicate.RemainingLifetime = deepcopy(self.RemainingLifetime, memo) memo[self] = Duplicate return\",\n \"if Exists is not Default: return Exists Duplicate = ProjectileClass(deepcopy(self.ID, memo), deepcopy(self.Owner ,memo),\",\n \"the set of feasible actions given the board size and position of the\",\n \"unit Extent: the space occupied by unit Position: location of unit Orientation: as\",\n \"-*- \\\"\\\"\\\" Created on Tue Dec 15 09:49:47 2020 @author: james.z.hare \\\"\\\"\\\" from\",\n \"range(Unit.Extent[1]) ]) return len(MyOccupiedSpace.intersection(TheirOccupiedSpace))>0 def execute(self, Actions, State): \\\"\\\"\\\" Execute `Actions` on `State`.\",\n \"} self.ActionOptions = ( ( \\\"advance\\\", ), ) self.Attack = None self.RemainingLifetime =\",\n \"Duplicate return Duplicate def possibleActions(self, State): \\\"\\\"\\\" Identifies the set of feasible actions\",\n \"units ActionOptions: list of list of action options. Attack: int that defines whether\",\n \"set([ (self.Position[0]+x, self.Position[1]+y, self.Position[2]) for x in range(self.Extent[0]) for y in range(self.Extent[1]) ])\",\n \"Duplicate.Attack = self.Attack Duplicate.RemainingLifetime = self.RemainingLifetime return Duplicate def __deepcopy__(self, memo): Default =\",\n \"the total number of turns until the unit is dead \\\"\\\"\\\" def __init__(self,\",\n \"Changes = [] for Action in Actions: ActionResult = self.Actions[Action](NewState) ActionResult[1].RemainingLifetime -= 1\",\n \"Unit.ID == self.ID: return Unit return None def overlaps(self, Unit): MyOccupiedSpace = set([\",\n \"execute(self, Actions, State): \\\"\\\"\\\" Execute `Actions` on `State`. Parameters ---------- Actions : list[str]\",\n \"for x in range(self.Extent[0]) for y in range(self.Extent[1]) ]) #print(Unit) TheirOccupiedSpace = set([\",\n \"ActionResult else: Changes.append(ActionResult) return Changes # Will be used as the projectile for\",\n \"- `__deepcopy__(memo)` to make deep copies - `possibleActions(State)` to identify legal actions -\",\n \"( \\\"advance\\\", ), ) self.Attack = None self.RemainingLifetime = RemainingLifetime def __copy__(self): Duplicate\",\n \"action options. Attack: int that defines whether the unit is attacking in an\",\n \"with another unit - `execute(Action, State)` to execute the action Attributes ---------- ID:\",\n \",memo), deepcopy(self.Health, memo)) Duplicate.Position = deepcopy(self.Position, memo) Duplicate.Orientation = deepcopy(self.Orientation, memo) Duplicate.Attack =\",\n \") self.Attack = None self.RemainingLifetime = RemainingLifetime def __copy__(self): Duplicate = ProjectileClass(self.ID, self.Owner,\",\n \"-*- coding: utf-8 -*- \\\"\\\"\\\" Created on Tue Dec 15 09:49:47 2020 @author:\",\n \"----------------- - `__copy__()` to make shallow copies - `__deepcopy__(memo)` to make deep copies\",\n \"set of actions to be performed on `State`. State : StateClass State on\",\n \"deepcopy(self.RemainingLifetime, memo) memo[self] = Duplicate return Duplicate def possibleActions(self, State): \\\"\\\"\\\" Identifies the\",\n \"self.RemainingLifetime return Duplicate def __deepcopy__(self, memo): Default = None Exists = memo.get(self, Default)\",\n \"Extent=(1,1)) self.Actions = { \\\"advance\\\": lambda x: advance(self, x) } self.ActionOptions = (\",\n \"Tue Dec 15 09:49:47 2020 @author: james.z.hare \\\"\\\"\\\" from src.UnitModule import UnitClass, advance\",\n \"`possibleActions(State)` to identify legal actions - `observe(Unit)` to observe units located within VisibleRange\",\n \"inflict actions. Returns ------- Changes : list Resulting state of executed `Actions`. \\\"\\\"\\\"\",\n \"actions common accross all units ActionOptions: list of list of action options. Attack:\",\n \"to the UnitClass Virtual Functions ----------------- - `__copy__()` to make shallow copies -\",\n \"unit overlaps with another unit - `execute(Action, State)` to execute the action Attributes\",\n \"UnitClass Virtual Functions ----------------- - `__copy__()` to make shallow copies - `__deepcopy__(memo)` to\",\n \"Duplicate = ProjectileClass(deepcopy(self.ID, memo), deepcopy(self.Owner ,memo), deepcopy(self.Health, memo)) Duplicate.Position = deepcopy(self.Position, memo) Duplicate.Orientation\",\n \"Duplicate.RemainingLifetime = self.RemainingLifetime return Duplicate def __deepcopy__(self, memo): Default = None Exists =\",\n \"of the unit Extent: the space occupied by unit Position: location of unit\",\n \"else: Changes.append(ActionResult) return Changes # Will be used as the projectile for the\",\n \"observe Actions: dict dictionary of actions common accross all units ActionOptions: list of\",\n \"Duplicate.RemainingLifetime = deepcopy(self.RemainingLifetime, memo) memo[self] = Duplicate return Duplicate def possibleActions(self, State): \\\"\\\"\\\"\",\n \"by unit Position: location of unit Orientation: as the name says VisibleRange: how\",\n \"x in range(Unit.Extent[0]) for y in range(Unit.Extent[1]) ]) return len(MyOccupiedSpace.intersection(TheirOccupiedSpace))>0 def execute(self, Actions,\",\n \"Position: location of unit Orientation: as the name says VisibleRange: how far the\",\n \"def observe(self, Unit): if Unit.ID == self.ID: return Unit return None def overlaps(self,\",\n \"State): \\\"\\\"\\\" Identifies the set of feasible actions given the board size and\",\n \"- `execute(Action, State)` to execute the action Attributes ---------- ID: a unique identifier\",\n \"TheirOccupiedSpace = set([ (Unit.Position[0]+x, Unit.Position[1]+y, Unit.Position[2]) for x in range(Unit.Extent[0]) for y in\",\n \"location of unit Orientation: as the name says VisibleRange: how far the unit\",\n \"ActionResult[1].RemainingLifetime -= 1 if isinstance(ActionResult, list): Changes += ActionResult else: Changes.append(ActionResult) return Changes\",\n \"#print(Unit) TheirOccupiedSpace = set([ (Unit.Position[0]+x, Unit.Position[1]+y, Unit.Position[2]) for x in range(Unit.Extent[0]) for y\",\n \"RemainingLifetime=math.inf): UnitClass.__init__(self, ID, Owner, Health, Extent=(1,1)) self.Actions = { \\\"advance\\\": lambda x: advance(self,\",\n \": list[str] A set of actions to be performed on `State`. State :\",\n \"list Resulting state of executed `Actions`. \\\"\\\"\\\" NewState = deepcopy(State) Changes = []\",\n \"of feasible actions given the board size and position of the unit Parameters\",\n \"overlaps(self, Unit): MyOccupiedSpace = set([ (self.Position[0]+x, self.Position[1]+y, self.Position[2]) for x in range(self.Extent[0]) for\",\n \"memo[self] = Duplicate return Duplicate def possibleActions(self, State): \\\"\\\"\\\" Identifies the set of\",\n \"None def overlaps(self, Unit): MyOccupiedSpace = set([ (self.Position[0]+x, self.Position[1]+y, self.Position[2]) for x in\",\n \"class ProjectileClass(UnitClass): \\\"\\\"\\\" The Projectile Class This is a subclass to the UnitClass\",\n \"unit belongs to Health: the health of the unit Extent: the space occupied\",\n \"state of executed `Actions`. \\\"\\\"\\\" NewState = deepcopy(State) Changes = [] for Action\",\n \"can observe Actions: dict dictionary of actions common accross all units ActionOptions: list\",\n \"Parameters ---------- State: StateClass Returns ------- TrueActions: list[str] A list of the feasible\",\n \"self.Position[2]) for x in range(self.Extent[0]) for y in range(self.Extent[1]) ]) #print(Unit) TheirOccupiedSpace =\",\n \"of list of action options. Attack: int that defines whether the unit is\",\n \"to inflict actions. Returns ------- Changes : list Resulting state of executed `Actions`.\",\n \"), ) self.Attack = None self.RemainingLifetime = RemainingLifetime def __copy__(self): Duplicate = ProjectileClass(self.ID,\",\n \"Health: the health of the unit Extent: the space occupied by unit Position:\",\n \"== self.ID: return Unit return None def overlaps(self, Unit): MyOccupiedSpace = set([ (self.Position[0]+x,\",\n \"total number of turns until the unit is dead \\\"\\\"\\\" def __init__(self, ID,\",\n \"actions given the board size and position of the unit Parameters ---------- State:\",\n \"Owner: the player the unit belongs to Health: the health of the unit\",\n \"Unit.Position[2]) for x in range(Unit.Extent[0]) for y in range(Unit.Extent[1]) ]) return len(MyOccupiedSpace.intersection(TheirOccupiedSpace))>0 def\",\n \"is a subclass to the UnitClass Virtual Functions ----------------- - `__copy__()` to make\",\n \"of action options. Attack: int that defines whether the unit is attacking in\",\n \"= self.Position Duplicate.Orientation = self.Orientation Duplicate.Attack = self.Attack Duplicate.RemainingLifetime = self.RemainingLifetime return Duplicate\",\n \"in range(Unit.Extent[1]) ]) return len(MyOccupiedSpace.intersection(TheirOccupiedSpace))>0 def execute(self, Actions, State): \\\"\\\"\\\" Execute `Actions` on\",\n \"return Duplicate def __deepcopy__(self, memo): Default = None Exists = memo.get(self, Default) if\",\n \"VisibleRange - `overlaps(Unit)` to identify if the unit overlaps with another unit -\",\n \"on Tue Dec 15 09:49:47 2020 @author: james.z.hare \\\"\\\"\\\" from src.UnitModule import UnitClass,\",\n \"def __copy__(self): Duplicate = ProjectileClass(self.ID, self.Owner, self.Health) Duplicate.Position = self.Position Duplicate.Orientation = self.Orientation\",\n \"( ( \\\"advance\\\", ), ) self.Attack = None self.RemainingLifetime = RemainingLifetime def __copy__(self):\",\n \"the unit Extent: the space occupied by unit Position: location of unit Orientation:\",\n \"def overlaps(self, Unit): MyOccupiedSpace = set([ (self.Position[0]+x, self.Position[1]+y, self.Position[2]) for x in range(self.Extent[0])\",\n \"which to inflict actions. Returns ------- Changes : list Resulting state of executed\",\n \"of executed `Actions`. \\\"\\\"\\\" NewState = deepcopy(State) Changes = [] for Action in\",\n \": StateClass State on which to inflict actions. Returns ------- Changes : list\",\n \"to observe units located within VisibleRange - `overlaps(Unit)` to identify if the unit\",\n \"`observe(Unit)` to observe units located within VisibleRange - `overlaps(Unit)` to identify if the\",\n \"= None self.RemainingLifetime = RemainingLifetime def __copy__(self): Duplicate = ProjectileClass(self.ID, self.Owner, self.Health) Duplicate.Position\",\n \"shallow copies - `__deepcopy__(memo)` to make deep copies - `possibleActions(State)` to identify legal\",\n \"be used as the projectile for the missile launcher unit class MissileClass(ProjectileClass): def\",\n \"turns until the unit is dead \\\"\\\"\\\" def __init__(self, ID, Owner, Health, RemainingLifetime=math.inf):\",\n \"\\\"advance\\\", ), ) self.Attack = None self.RemainingLifetime = RemainingLifetime def __copy__(self): Duplicate =\",\n \"isinstance(ActionResult, list): Changes += ActionResult else: Changes.append(ActionResult) return Changes # Will be used\",\n \"return Unit return None def overlaps(self, Unit): MyOccupiedSpace = set([ (self.Position[0]+x, self.Position[1]+y, self.Position[2])\",\n \"Execute `Actions` on `State`. Parameters ---------- Actions : list[str] A set of actions\",\n \"that defines whether the unit is attacking in an advance action RemaingLifetime: int\",\n \"---------- Actions : list[str] A set of actions to be performed on `State`.\",\n \"Projectile Class This is a subclass to the UnitClass Virtual Functions ----------------- -\",\n \"on which to inflict actions. Returns ------- Changes : list Resulting state of\",\n \": list Resulting state of executed `Actions`. \\\"\\\"\\\" NewState = deepcopy(State) Changes =\",\n \"Functions ----------------- - `__copy__()` to make shallow copies - `__deepcopy__(memo)` to make deep\",\n \"__copy__(self): Duplicate = ProjectileClass(self.ID, self.Owner, self.Health) Duplicate.Position = self.Position Duplicate.Orientation = self.Orientation Duplicate.Attack\",\n \"- `overlaps(Unit)` to identify if the unit overlaps with another unit - `execute(Action,\",\n \"(Unit.Position[0]+x, Unit.Position[1]+y, Unit.Position[2]) for x in range(Unit.Extent[0]) for y in range(Unit.Extent[1]) ]) return\",\n \"self.Attack Duplicate.RemainingLifetime = self.RemainingLifetime return Duplicate def __deepcopy__(self, memo): Default = None Exists\",\n \"space occupied by unit Position: location of unit Orientation: as the name says\",\n \"Changes.append(ActionResult) return Changes # Will be used as the projectile for the missile\",\n \"2020 @author: james.z.hare \\\"\\\"\\\" from src.UnitModule import UnitClass, advance from copy import deepcopy\",\n \"in range(self.Extent[0]) for y in range(self.Extent[1]) ]) #print(Unit) TheirOccupiedSpace = set([ (Unit.Position[0]+x, Unit.Position[1]+y,\",\n \"ProjectileClass(self.ID, self.Owner, self.Health) Duplicate.Position = self.Position Duplicate.Orientation = self.Orientation Duplicate.Attack = self.Attack Duplicate.RemainingLifetime\",\n \"list): Changes += ActionResult else: Changes.append(ActionResult) return Changes # Will be used as\",\n \"`execute(Action, State)` to execute the action Attributes ---------- ID: a unique identifier of\",\n \"the unit is dead \\\"\\\"\\\" def __init__(self, ID, Owner, Health, RemainingLifetime=math.inf): UnitClass.__init__(self, ID,\",\n \"(self.Position[0]+x, self.Position[1]+y, self.Position[2]) for x in range(self.Extent[0]) for y in range(self.Extent[1]) ]) #print(Unit)\"\n]","isConversational":false}}},{"rowIdx":4495,"cells":{"ngram":{"kind":"list like","value":["from car import * def compare(car1,car2): print(car1) print(car2) car1 = Car(\"Nissan\",\"Tiida\",450000) car2 =","* def compare(car1,car2): print(car1) print(car2) car1 = Car(\"Nissan\",\"Tiida\",450000) car2 = Car(\"Toyota\",\"Vios\",400000) car3 =","compare(car1,car2): print(car1) print(car2) car1 = Car(\"Nissan\",\"Tiida\",450000) car2 = Car(\"Toyota\",\"Vios\",400000) car3 = Car(\"BMW\",\"X3\",3400000) compare(car3,car1)","print(car1) print(car2) car1 = Car(\"Nissan\",\"Tiida\",450000) car2 = Car(\"Toyota\",\"Vios\",400000) car3 = Car(\"BMW\",\"X3\",3400000) compare(car3,car1) compare(car1,car2)","def compare(car1,car2): print(car1) print(car2) car1 = Car(\"Nissan\",\"Tiida\",450000) car2 = Car(\"Toyota\",\"Vios\",400000) car3 = Car(\"BMW\",\"X3\",3400000)","import * def compare(car1,car2): print(car1) print(car2) car1 = Car(\"Nissan\",\"Tiida\",450000) car2 = Car(\"Toyota\",\"Vios\",400000) car3","car import * def compare(car1,car2): print(car1) print(car2) car1 = Car(\"Nissan\",\"Tiida\",450000) car2 = Car(\"Toyota\",\"Vios\",400000)"],"string":"[\n \"from car import * def compare(car1,car2): print(car1) print(car2) car1 = Car(\\\"Nissan\\\",\\\"Tiida\\\",450000) car2 =\",\n \"* def compare(car1,car2): print(car1) print(car2) car1 = Car(\\\"Nissan\\\",\\\"Tiida\\\",450000) car2 = Car(\\\"Toyota\\\",\\\"Vios\\\",400000) car3 =\",\n \"compare(car1,car2): print(car1) print(car2) car1 = Car(\\\"Nissan\\\",\\\"Tiida\\\",450000) car2 = Car(\\\"Toyota\\\",\\\"Vios\\\",400000) car3 = Car(\\\"BMW\\\",\\\"X3\\\",3400000) compare(car3,car1)\",\n \"print(car1) print(car2) car1 = Car(\\\"Nissan\\\",\\\"Tiida\\\",450000) car2 = Car(\\\"Toyota\\\",\\\"Vios\\\",400000) car3 = Car(\\\"BMW\\\",\\\"X3\\\",3400000) compare(car3,car1) compare(car1,car2)\",\n \"def compare(car1,car2): print(car1) print(car2) car1 = Car(\\\"Nissan\\\",\\\"Tiida\\\",450000) car2 = Car(\\\"Toyota\\\",\\\"Vios\\\",400000) car3 = Car(\\\"BMW\\\",\\\"X3\\\",3400000)\",\n \"import * def compare(car1,car2): print(car1) print(car2) car1 = Car(\\\"Nissan\\\",\\\"Tiida\\\",450000) car2 = Car(\\\"Toyota\\\",\\\"Vios\\\",400000) car3\",\n \"car import * def compare(car1,car2): print(car1) print(car2) car1 = Car(\\\"Nissan\\\",\\\"Tiida\\\",450000) car2 = Car(\\\"Toyota\\\",\\\"Vios\\\",400000)\"\n]","isConversational":false}}},{"rowIdx":4496,"cells":{"ngram":{"kind":"list like","value":["def __iter__(self): yield self.__val def __repr__(self): return \"Just({})\".format(self.__val) @singleton class Nothing(Maybe): def __rshift__(self,","self.__val def __repr__(self): return \"Just({})\".format(self.__val) @singleton class Nothing(Maybe): def __rshift__(self, f): return self","val): self.__val = val def __rshift__(self, f): return self def __iter__(self): return iter([])","== type(other) def __repr__(self): return \"Left({})\".format(self.__val) class Right(Either): def __init__(self, val): self.__val =","= ABCMeta @classmethod def mreturn(cls, val): return Right(val) @abstractmethod def __iter__(self): pass class","def __eq__(self, other): return type(self) == type(other) def __repr__(self): return \"Left({})\".format(self.__val) class Right(Either):","class Right(Either): def __init__(self, val): self.__val = val def __rshift__(self, f): return f(self.__val)","ABCMeta @classmethod def mreturn(cls, val): return Just(val) @abstractmethod def __iter__(self): pass @monad_eq class","return f(self.__val) def __iter__(self): yield self.__val def __repr__(self): return \"Just({})\".format(self.__val) @singleton class Nothing(Maybe):","\"Left({})\".format(self.__val) class Right(Either): def __init__(self, val): self.__val = val def __rshift__(self, f): return","__rshift__(self, f): return f(self.__val) def __iter__(self): yield self.__val def __repr__(self): return \"Right({})\".format(self.__val) class","\"Right({})\".format(self.__val) class Maybe(Monad): __metaclass__ = ABCMeta @classmethod def mreturn(cls, val): return Just(val) @abstractmethod","singleton @monad_eq class Either(Monad): __metaclass__ = ABCMeta @classmethod def mreturn(cls, val): return Right(val)","monad_eq, singleton @monad_eq class Either(Monad): __metaclass__ = ABCMeta @classmethod def mreturn(cls, val): return","__init__(self, val): self.__val = val def __rshift__(self, f): return self def __iter__(self): return","mreturn(cls, val): return Right(val) @abstractmethod def __iter__(self): pass class Left(Either): def __init__(self, val):","__iter__(self): return iter([]) def __eq__(self, other): return type(self) == type(other) def __repr__(self): return","return \"Left({})\".format(self.__val) class Right(Either): def __init__(self, val): self.__val = val def __rshift__(self, f):","val def __rshift__(self, f): return self def __iter__(self): return iter([]) def __eq__(self, other):","self.__val = val def __rshift__(self, f): return self def __iter__(self): return iter([]) def","yield self.__val def __repr__(self): return \"Right({})\".format(self.__val) class Maybe(Monad): __metaclass__ = ABCMeta @classmethod def","class Maybe(Monad): __metaclass__ = ABCMeta @classmethod def mreturn(cls, val): return Just(val) @abstractmethod def","__repr__(self): return \"Right({})\".format(self.__val) class Maybe(Monad): __metaclass__ = ABCMeta @classmethod def mreturn(cls, val): return","__rshift__(self, f): return f(self.__val) def __iter__(self): yield self.__val def __repr__(self): return \"Just({})\".format(self.__val) @singleton","val): return Just(val) @abstractmethod def __iter__(self): pass @monad_eq class Just(Maybe): def __init__(self, val):","self def __iter__(self): return iter([]) def __eq__(self, other): return type(self) == type(other) def","__rshift__(self, f): return self def __iter__(self): return iter([]) def __eq__(self, other): return type(self)","__iter__(self): pass @monad_eq class Just(Maybe): def __init__(self, val): self.__val = val def __rshift__(self,","def __iter__(self): pass class Left(Either): def __init__(self, val): self.__val = val def __rshift__(self,","self.__val def __repr__(self): return \"Right({})\".format(self.__val) class Maybe(Monad): __metaclass__ = ABCMeta @classmethod def mreturn(cls,","return \"Right({})\".format(self.__val) class Maybe(Monad): __metaclass__ = ABCMeta @classmethod def mreturn(cls, val): return Just(val)","self.__val = val def __rshift__(self, f): return f(self.__val) def __iter__(self): yield self.__val def","return iter([]) def __eq__(self, other): return type(self) == type(other) def __repr__(self): return \"Left({})\".format(self.__val)","f): return self def __iter__(self): return iter([]) def __eq__(self, other): return type(self) ==","class Either(Monad): __metaclass__ = ABCMeta @classmethod def mreturn(cls, val): return Right(val) @abstractmethod def","def __init__(self, val): self.__val = val def __rshift__(self, f): return self def __iter__(self):","Left(Either): def __init__(self, val): self.__val = val def __rshift__(self, f): return self def","Just(val) @abstractmethod def __iter__(self): pass @monad_eq class Just(Maybe): def __init__(self, val): self.__val =","f(self.__val) def __iter__(self): yield self.__val def __repr__(self): return \"Right({})\".format(self.__val) class Maybe(Monad): __metaclass__ =","@classmethod def mreturn(cls, val): return Just(val) @abstractmethod def __iter__(self): pass @monad_eq class Just(Maybe):","return Right(val) @abstractmethod def __iter__(self): pass class Left(Either): def __init__(self, val): self.__val =","def __rshift__(self, f): return f(self.__val) def __iter__(self): yield self.__val def __repr__(self): return \"Just({})\".format(self.__val)","from abc import ABCMeta, abstractmethod from prelude.typeclasses import Monad from prelude.decorators import monad_eq,","prelude.decorators import monad_eq, singleton @monad_eq class Either(Monad): __metaclass__ = ABCMeta @classmethod def mreturn(cls,","abc import ABCMeta, abstractmethod from prelude.typeclasses import Monad from prelude.decorators import monad_eq, singleton","@classmethod def mreturn(cls, val): return Right(val) @abstractmethod def __iter__(self): pass class Left(Either): def","Just(Maybe): def __init__(self, val): self.__val = val def __rshift__(self, f): return f(self.__val) def","return Just(val) @abstractmethod def __iter__(self): pass @monad_eq class Just(Maybe): def __init__(self, val): self.__val","def __init__(self, val): self.__val = val def __rshift__(self, f): return f(self.__val) def __iter__(self):","Right(Either): def __init__(self, val): self.__val = val def __rshift__(self, f): return f(self.__val) def","@abstractmethod def __iter__(self): pass @monad_eq class Just(Maybe): def __init__(self, val): self.__val = val","val): return Right(val) @abstractmethod def __iter__(self): pass class Left(Either): def __init__(self, val): self.__val","\"Just({})\".format(self.__val) @singleton class Nothing(Maybe): def __rshift__(self, f): return self def __iter__(self): return iter([])","__iter__(self): yield self.__val def __repr__(self): return \"Just({})\".format(self.__val) @singleton class Nothing(Maybe): def __rshift__(self, f):","import Monad from prelude.decorators import monad_eq, singleton @monad_eq class Either(Monad): __metaclass__ = ABCMeta","class Nothing(Maybe): def __rshift__(self, f): return self def __iter__(self): return iter([]) def __repr__(self):","def __iter__(self): pass @monad_eq class Just(Maybe): def __init__(self, val): self.__val = val def","f): return f(self.__val) def __iter__(self): yield self.__val def __repr__(self): return \"Just({})\".format(self.__val) @singleton class","Maybe(Monad): __metaclass__ = ABCMeta @classmethod def mreturn(cls, val): return Just(val) @abstractmethod def __iter__(self):","= ABCMeta @classmethod def mreturn(cls, val): return Just(val) @abstractmethod def __iter__(self): pass @monad_eq","class Left(Either): def __init__(self, val): self.__val = val def __rshift__(self, f): return self","import monad_eq, singleton @monad_eq class Either(Monad): __metaclass__ = ABCMeta @classmethod def mreturn(cls, val):","from prelude.typeclasses import Monad from prelude.decorators import monad_eq, singleton @monad_eq class Either(Monad): __metaclass__","def mreturn(cls, val): return Just(val) @abstractmethod def __iter__(self): pass @monad_eq class Just(Maybe): def","__iter__(self): pass class Left(Either): def __init__(self, val): self.__val = val def __rshift__(self, f):","def __iter__(self): yield self.__val def __repr__(self): return \"Right({})\".format(self.__val) class Maybe(Monad): __metaclass__ = ABCMeta","__metaclass__ = ABCMeta @classmethod def mreturn(cls, val): return Right(val) @abstractmethod def __iter__(self): pass","type(other) def __repr__(self): return \"Left({})\".format(self.__val) class Right(Either): def __init__(self, val): self.__val = val","@monad_eq class Either(Monad): __metaclass__ = ABCMeta @classmethod def mreturn(cls, val): return Right(val) @abstractmethod","ABCMeta, abstractmethod from prelude.typeclasses import Monad from prelude.decorators import monad_eq, singleton @monad_eq class","return self def __iter__(self): return iter([]) def __eq__(self, other): return type(self) == type(other)","@abstractmethod def __iter__(self): pass class Left(Either): def __init__(self, val): self.__val = val def","def __rshift__(self, f): return self def __iter__(self): return iter([]) def __repr__(self): return \"Nothing()\"","prelude.typeclasses import Monad from prelude.decorators import monad_eq, singleton @monad_eq class Either(Monad): __metaclass__ =","= val def __rshift__(self, f): return f(self.__val) def __iter__(self): yield self.__val def __repr__(self):","other): return type(self) == type(other) def __repr__(self): return \"Left({})\".format(self.__val) class Right(Either): def __init__(self,","class Just(Maybe): def __init__(self, val): self.__val = val def __rshift__(self, f): return f(self.__val)","__repr__(self): return \"Just({})\".format(self.__val) @singleton class Nothing(Maybe): def __rshift__(self, f): return self def __iter__(self):","iter([]) def __eq__(self, other): return type(self) == type(other) def __repr__(self): return \"Left({})\".format(self.__val) class","f): return f(self.__val) def __iter__(self): yield self.__val def __repr__(self): return \"Right({})\".format(self.__val) class Maybe(Monad):","return f(self.__val) def __iter__(self): yield self.__val def __repr__(self): return \"Right({})\".format(self.__val) class Maybe(Monad): __metaclass__","pass @monad_eq class Just(Maybe): def __init__(self, val): self.__val = val def __rshift__(self, f):","import ABCMeta, abstractmethod from prelude.typeclasses import Monad from prelude.decorators import monad_eq, singleton @monad_eq","__repr__(self): return \"Left({})\".format(self.__val) class Right(Either): def __init__(self, val): self.__val = val def __rshift__(self,","abstractmethod from prelude.typeclasses import Monad from prelude.decorators import monad_eq, singleton @monad_eq class Either(Monad):","Either(Monad): __metaclass__ = ABCMeta @classmethod def mreturn(cls, val): return Right(val) @abstractmethod def __iter__(self):","def __rshift__(self, f): return self def __iter__(self): return iter([]) def __eq__(self, other): return","__metaclass__ = ABCMeta @classmethod def mreturn(cls, val): return Just(val) @abstractmethod def __iter__(self): pass","ABCMeta @classmethod def mreturn(cls, val): return Right(val) @abstractmethod def __iter__(self): pass class Left(Either):","def __repr__(self): return \"Right({})\".format(self.__val) class Maybe(Monad): __metaclass__ = ABCMeta @classmethod def mreturn(cls, val):","@monad_eq class Just(Maybe): def __init__(self, val): self.__val = val def __rshift__(self, f): return","def __repr__(self): return \"Just({})\".format(self.__val) @singleton class Nothing(Maybe): def __rshift__(self, f): return self def","@singleton class Nothing(Maybe): def __rshift__(self, f): return self def __iter__(self): return iter([]) def","= val def __rshift__(self, f): return self def __iter__(self): return iter([]) def __eq__(self,","from prelude.decorators import monad_eq, singleton @monad_eq class Either(Monad): __metaclass__ = ABCMeta @classmethod def","yield self.__val def __repr__(self): return \"Just({})\".format(self.__val) @singleton class Nothing(Maybe): def __rshift__(self, f): return","mreturn(cls, val): return Just(val) @abstractmethod def __iter__(self): pass @monad_eq class Just(Maybe): def __init__(self,","return \"Just({})\".format(self.__val) @singleton class Nothing(Maybe): def __rshift__(self, f): return self def __iter__(self): return","type(self) == type(other) def __repr__(self): return \"Left({})\".format(self.__val) class Right(Either): def __init__(self, val): self.__val","val def __rshift__(self, f): return f(self.__val) def __iter__(self): yield self.__val def __repr__(self): return","__init__(self, val): self.__val = val def __rshift__(self, f): return f(self.__val) def __iter__(self): yield","Right(val) @abstractmethod def __iter__(self): pass class Left(Either): def __init__(self, val): self.__val = val","return type(self) == type(other) def __repr__(self): return \"Left({})\".format(self.__val) class Right(Either): def __init__(self, val):","Monad from prelude.decorators import monad_eq, singleton @monad_eq class Either(Monad): __metaclass__ = ABCMeta @classmethod","__iter__(self): yield self.__val def __repr__(self): return \"Right({})\".format(self.__val) class Maybe(Monad): __metaclass__ = ABCMeta @classmethod","f(self.__val) def __iter__(self): yield self.__val def __repr__(self): return \"Just({})\".format(self.__val) @singleton class Nothing(Maybe): def","def __iter__(self): return iter([]) def __eq__(self, other): return type(self) == type(other) def __repr__(self):","val): self.__val = val def __rshift__(self, f): return f(self.__val) def __iter__(self): yield self.__val","pass class Left(Either): def __init__(self, val): self.__val = val def __rshift__(self, f): return","def __rshift__(self, f): return f(self.__val) def __iter__(self): yield self.__val def __repr__(self): return \"Right({})\".format(self.__val)","Nothing(Maybe): def __rshift__(self, f): return self def __iter__(self): return iter([]) def __repr__(self): return","def __repr__(self): return \"Left({})\".format(self.__val) class Right(Either): def __init__(self, val): self.__val = val def","def mreturn(cls, val): return Right(val) @abstractmethod def __iter__(self): pass class Left(Either): def __init__(self,","__eq__(self, other): return type(self) == type(other) def __repr__(self): return \"Left({})\".format(self.__val) class Right(Either): def"],"string":"[\n \"def __iter__(self): yield self.__val def __repr__(self): return \\\"Just({})\\\".format(self.__val) @singleton class Nothing(Maybe): def __rshift__(self,\",\n \"self.__val def __repr__(self): return \\\"Just({})\\\".format(self.__val) @singleton class Nothing(Maybe): def __rshift__(self, f): return self\",\n \"val): self.__val = val def __rshift__(self, f): return self def __iter__(self): return iter([])\",\n \"== type(other) def __repr__(self): return \\\"Left({})\\\".format(self.__val) class Right(Either): def __init__(self, val): self.__val =\",\n \"= ABCMeta @classmethod def mreturn(cls, val): return Right(val) @abstractmethod def __iter__(self): pass class\",\n \"def __eq__(self, other): return type(self) == type(other) def __repr__(self): return \\\"Left({})\\\".format(self.__val) class Right(Either):\",\n \"class Right(Either): def __init__(self, val): self.__val = val def __rshift__(self, f): return f(self.__val)\",\n \"ABCMeta @classmethod def mreturn(cls, val): return Just(val) @abstractmethod def __iter__(self): pass @monad_eq class\",\n \"return f(self.__val) def __iter__(self): yield self.__val def __repr__(self): return \\\"Just({})\\\".format(self.__val) @singleton class Nothing(Maybe):\",\n \"\\\"Left({})\\\".format(self.__val) class Right(Either): def __init__(self, val): self.__val = val def __rshift__(self, f): return\",\n \"__rshift__(self, f): return f(self.__val) def __iter__(self): yield self.__val def __repr__(self): return \\\"Right({})\\\".format(self.__val) class\",\n \"\\\"Right({})\\\".format(self.__val) class Maybe(Monad): __metaclass__ = ABCMeta @classmethod def mreturn(cls, val): return Just(val) @abstractmethod\",\n \"singleton @monad_eq class Either(Monad): __metaclass__ = ABCMeta @classmethod def mreturn(cls, val): return Right(val)\",\n \"monad_eq, singleton @monad_eq class Either(Monad): __metaclass__ = ABCMeta @classmethod def mreturn(cls, val): return\",\n \"__init__(self, val): self.__val = val def __rshift__(self, f): return self def __iter__(self): return\",\n \"mreturn(cls, val): return Right(val) @abstractmethod def __iter__(self): pass class Left(Either): def __init__(self, val):\",\n \"__iter__(self): return iter([]) def __eq__(self, other): return type(self) == type(other) def __repr__(self): return\",\n \"return \\\"Left({})\\\".format(self.__val) class Right(Either): def __init__(self, val): self.__val = val def __rshift__(self, f):\",\n \"val def __rshift__(self, f): return self def __iter__(self): return iter([]) def __eq__(self, other):\",\n \"self.__val = val def __rshift__(self, f): return self def __iter__(self): return iter([]) def\",\n \"yield self.__val def __repr__(self): return \\\"Right({})\\\".format(self.__val) class Maybe(Monad): __metaclass__ = ABCMeta @classmethod def\",\n \"class Maybe(Monad): __metaclass__ = ABCMeta @classmethod def mreturn(cls, val): return Just(val) @abstractmethod def\",\n \"__repr__(self): return \\\"Right({})\\\".format(self.__val) class Maybe(Monad): __metaclass__ = ABCMeta @classmethod def mreturn(cls, val): return\",\n \"__rshift__(self, f): return f(self.__val) def __iter__(self): yield self.__val def __repr__(self): return \\\"Just({})\\\".format(self.__val) @singleton\",\n \"val): return Just(val) @abstractmethod def __iter__(self): pass @monad_eq class Just(Maybe): def __init__(self, val):\",\n \"self def __iter__(self): return iter([]) def __eq__(self, other): return type(self) == type(other) def\",\n \"__rshift__(self, f): return self def __iter__(self): return iter([]) def __eq__(self, other): return type(self)\",\n \"__iter__(self): pass @monad_eq class Just(Maybe): def __init__(self, val): self.__val = val def __rshift__(self,\",\n \"def __iter__(self): pass class Left(Either): def __init__(self, val): self.__val = val def __rshift__(self,\",\n \"self.__val def __repr__(self): return \\\"Right({})\\\".format(self.__val) class Maybe(Monad): __metaclass__ = ABCMeta @classmethod def mreturn(cls,\",\n \"return \\\"Right({})\\\".format(self.__val) class Maybe(Monad): __metaclass__ = ABCMeta @classmethod def mreturn(cls, val): return Just(val)\",\n \"self.__val = val def __rshift__(self, f): return f(self.__val) def __iter__(self): yield self.__val def\",\n \"return iter([]) def __eq__(self, other): return type(self) == type(other) def __repr__(self): return \\\"Left({})\\\".format(self.__val)\",\n \"f): return self def __iter__(self): return iter([]) def __eq__(self, other): return type(self) ==\",\n \"class Either(Monad): __metaclass__ = ABCMeta @classmethod def mreturn(cls, val): return Right(val) @abstractmethod def\",\n \"def __init__(self, val): self.__val = val def __rshift__(self, f): return self def __iter__(self):\",\n \"Left(Either): def __init__(self, val): self.__val = val def __rshift__(self, f): return self def\",\n \"Just(val) @abstractmethod def __iter__(self): pass @monad_eq class Just(Maybe): def __init__(self, val): self.__val =\",\n \"f(self.__val) def __iter__(self): yield self.__val def __repr__(self): return \\\"Right({})\\\".format(self.__val) class Maybe(Monad): __metaclass__ =\",\n \"@classmethod def mreturn(cls, val): return Just(val) @abstractmethod def __iter__(self): pass @monad_eq class Just(Maybe):\",\n \"return Right(val) @abstractmethod def __iter__(self): pass class Left(Either): def __init__(self, val): self.__val =\",\n \"def __rshift__(self, f): return f(self.__val) def __iter__(self): yield self.__val def __repr__(self): return \\\"Just({})\\\".format(self.__val)\",\n \"from abc import ABCMeta, abstractmethod from prelude.typeclasses import Monad from prelude.decorators import monad_eq,\",\n \"prelude.decorators import monad_eq, singleton @monad_eq class Either(Monad): __metaclass__ = ABCMeta @classmethod def mreturn(cls,\",\n \"abc import ABCMeta, abstractmethod from prelude.typeclasses import Monad from prelude.decorators import monad_eq, singleton\",\n \"@classmethod def mreturn(cls, val): return Right(val) @abstractmethod def __iter__(self): pass class Left(Either): def\",\n \"Just(Maybe): def __init__(self, val): self.__val = val def __rshift__(self, f): return f(self.__val) def\",\n \"return Just(val) @abstractmethod def __iter__(self): pass @monad_eq class Just(Maybe): def __init__(self, val): self.__val\",\n \"def __init__(self, val): self.__val = val def __rshift__(self, f): return f(self.__val) def __iter__(self):\",\n \"Right(Either): def __init__(self, val): self.__val = val def __rshift__(self, f): return f(self.__val) def\",\n \"@abstractmethod def __iter__(self): pass @monad_eq class Just(Maybe): def __init__(self, val): self.__val = val\",\n \"val): return Right(val) @abstractmethod def __iter__(self): pass class Left(Either): def __init__(self, val): self.__val\",\n \"\\\"Just({})\\\".format(self.__val) @singleton class Nothing(Maybe): def __rshift__(self, f): return self def __iter__(self): return iter([])\",\n \"__iter__(self): yield self.__val def __repr__(self): return \\\"Just({})\\\".format(self.__val) @singleton class Nothing(Maybe): def __rshift__(self, f):\",\n \"import Monad from prelude.decorators import monad_eq, singleton @monad_eq class Either(Monad): __metaclass__ = ABCMeta\",\n \"class Nothing(Maybe): def __rshift__(self, f): return self def __iter__(self): return iter([]) def __repr__(self):\",\n \"def __iter__(self): pass @monad_eq class Just(Maybe): def __init__(self, val): self.__val = val def\",\n \"f): return f(self.__val) def __iter__(self): yield self.__val def __repr__(self): return \\\"Just({})\\\".format(self.__val) @singleton class\",\n \"Maybe(Monad): __metaclass__ = ABCMeta @classmethod def mreturn(cls, val): return Just(val) @abstractmethod def __iter__(self):\",\n \"= ABCMeta @classmethod def mreturn(cls, val): return Just(val) @abstractmethod def __iter__(self): pass @monad_eq\",\n \"class Left(Either): def __init__(self, val): self.__val = val def __rshift__(self, f): return self\",\n \"import monad_eq, singleton @monad_eq class Either(Monad): __metaclass__ = ABCMeta @classmethod def mreturn(cls, val):\",\n \"from prelude.typeclasses import Monad from prelude.decorators import monad_eq, singleton @monad_eq class Either(Monad): __metaclass__\",\n \"def mreturn(cls, val): return Just(val) @abstractmethod def __iter__(self): pass @monad_eq class Just(Maybe): def\",\n \"__iter__(self): pass class Left(Either): def __init__(self, val): self.__val = val def __rshift__(self, f):\",\n \"def __iter__(self): yield self.__val def __repr__(self): return \\\"Right({})\\\".format(self.__val) class Maybe(Monad): __metaclass__ = ABCMeta\",\n \"__metaclass__ = ABCMeta @classmethod def mreturn(cls, val): return Right(val) @abstractmethod def __iter__(self): pass\",\n \"type(other) def __repr__(self): return \\\"Left({})\\\".format(self.__val) class Right(Either): def __init__(self, val): self.__val = val\",\n \"@monad_eq class Either(Monad): __metaclass__ = ABCMeta @classmethod def mreturn(cls, val): return Right(val) @abstractmethod\",\n \"ABCMeta, abstractmethod from prelude.typeclasses import Monad from prelude.decorators import monad_eq, singleton @monad_eq class\",\n \"return self def __iter__(self): return iter([]) def __eq__(self, other): return type(self) == type(other)\",\n \"@abstractmethod def __iter__(self): pass class Left(Either): def __init__(self, val): self.__val = val def\",\n \"def __rshift__(self, f): return self def __iter__(self): return iter([]) def __repr__(self): return \\\"Nothing()\\\"\",\n \"prelude.typeclasses import Monad from prelude.decorators import monad_eq, singleton @monad_eq class Either(Monad): __metaclass__ =\",\n \"= val def __rshift__(self, f): return f(self.__val) def __iter__(self): yield self.__val def __repr__(self):\",\n \"other): return type(self) == type(other) def __repr__(self): return \\\"Left({})\\\".format(self.__val) class Right(Either): def __init__(self,\",\n \"class Just(Maybe): def __init__(self, val): self.__val = val def __rshift__(self, f): return f(self.__val)\",\n \"__repr__(self): return \\\"Just({})\\\".format(self.__val) @singleton class Nothing(Maybe): def __rshift__(self, f): return self def __iter__(self):\",\n \"iter([]) def __eq__(self, other): return type(self) == type(other) def __repr__(self): return \\\"Left({})\\\".format(self.__val) class\",\n \"f): return f(self.__val) def __iter__(self): yield self.__val def __repr__(self): return \\\"Right({})\\\".format(self.__val) class Maybe(Monad):\",\n \"return f(self.__val) def __iter__(self): yield self.__val def __repr__(self): return \\\"Right({})\\\".format(self.__val) class Maybe(Monad): __metaclass__\",\n \"pass @monad_eq class Just(Maybe): def __init__(self, val): self.__val = val def __rshift__(self, f):\",\n \"import ABCMeta, abstractmethod from prelude.typeclasses import Monad from prelude.decorators import monad_eq, singleton @monad_eq\",\n \"__repr__(self): return \\\"Left({})\\\".format(self.__val) class Right(Either): def __init__(self, val): self.__val = val def __rshift__(self,\",\n \"abstractmethod from prelude.typeclasses import Monad from prelude.decorators import monad_eq, singleton @monad_eq class Either(Monad):\",\n \"Either(Monad): __metaclass__ = ABCMeta @classmethod def mreturn(cls, val): return Right(val) @abstractmethod def __iter__(self):\",\n \"def __rshift__(self, f): return self def __iter__(self): return iter([]) def __eq__(self, other): return\",\n \"__metaclass__ = ABCMeta @classmethod def mreturn(cls, val): return Just(val) @abstractmethod def __iter__(self): pass\",\n \"ABCMeta @classmethod def mreturn(cls, val): return Right(val) @abstractmethod def __iter__(self): pass class Left(Either):\",\n \"def __repr__(self): return \\\"Right({})\\\".format(self.__val) class Maybe(Monad): __metaclass__ = ABCMeta @classmethod def mreturn(cls, val):\",\n \"@monad_eq class Just(Maybe): def __init__(self, val): self.__val = val def __rshift__(self, f): return\",\n \"def __repr__(self): return \\\"Just({})\\\".format(self.__val) @singleton class Nothing(Maybe): def __rshift__(self, f): return self def\",\n \"@singleton class Nothing(Maybe): def __rshift__(self, f): return self def __iter__(self): return iter([]) def\",\n \"= val def __rshift__(self, f): return self def __iter__(self): return iter([]) def __eq__(self,\",\n \"from prelude.decorators import monad_eq, singleton @monad_eq class Either(Monad): __metaclass__ = ABCMeta @classmethod def\",\n \"yield self.__val def __repr__(self): return \\\"Just({})\\\".format(self.__val) @singleton class Nothing(Maybe): def __rshift__(self, f): return\",\n \"mreturn(cls, val): return Just(val) @abstractmethod def __iter__(self): pass @monad_eq class Just(Maybe): def __init__(self,\",\n \"return \\\"Just({})\\\".format(self.__val) @singleton class Nothing(Maybe): def __rshift__(self, f): return self def __iter__(self): return\",\n \"type(self) == type(other) def __repr__(self): return \\\"Left({})\\\".format(self.__val) class Right(Either): def __init__(self, val): self.__val\",\n \"val def __rshift__(self, f): return f(self.__val) def __iter__(self): yield self.__val def __repr__(self): return\",\n \"__init__(self, val): self.__val = val def __rshift__(self, f): return f(self.__val) def __iter__(self): yield\",\n \"Right(val) @abstractmethod def __iter__(self): pass class Left(Either): def __init__(self, val): self.__val = val\",\n \"return type(self) == type(other) def __repr__(self): return \\\"Left({})\\\".format(self.__val) class Right(Either): def __init__(self, val):\",\n \"Monad from prelude.decorators import monad_eq, singleton @monad_eq class Either(Monad): __metaclass__ = ABCMeta @classmethod\",\n \"__iter__(self): yield self.__val def __repr__(self): return \\\"Right({})\\\".format(self.__val) class Maybe(Monad): __metaclass__ = ABCMeta @classmethod\",\n \"f(self.__val) def __iter__(self): yield self.__val def __repr__(self): return \\\"Just({})\\\".format(self.__val) @singleton class Nothing(Maybe): def\",\n \"def __iter__(self): return iter([]) def __eq__(self, other): return type(self) == type(other) def __repr__(self):\",\n \"val): self.__val = val def __rshift__(self, f): return f(self.__val) def __iter__(self): yield self.__val\",\n \"pass class Left(Either): def __init__(self, val): self.__val = val def __rshift__(self, f): return\",\n \"def __rshift__(self, f): return f(self.__val) def __iter__(self): yield self.__val def __repr__(self): return \\\"Right({})\\\".format(self.__val)\",\n \"Nothing(Maybe): def __rshift__(self, f): return self def __iter__(self): return iter([]) def __repr__(self): return\",\n \"def __repr__(self): return \\\"Left({})\\\".format(self.__val) class Right(Either): def __init__(self, val): self.__val = val def\",\n \"def mreturn(cls, val): return Right(val) @abstractmethod def __iter__(self): pass class Left(Either): def __init__(self,\",\n \"__eq__(self, other): return type(self) == type(other) def __repr__(self): return \\\"Left({})\\\".format(self.__val) class Right(Either): def\"\n]","isConversational":false}}},{"rowIdx":4497,"cells":{"ngram":{"kind":"list like","value":["CvBridge() self.image_sub = rospy.Subscriber(\"/bebop/image_raw\",Image,self.callback) def callback(self,data): try: cv_image = self.bridge.imgmsg_to_cv2(data, \"bgr8\") except CvBridgeError","cv2.imshow(\"hola\", cv_image) cv2.waitKey(3) def main(args): while True: ic = image_converter() rospy.init_node('image_converter', anonymous=True) \"\"\"","import rospy import cv2 from std_msgs.msg import String from sensor_msgs.msg import Image from","ic = image_converter() rospy.init_node('image_converter', anonymous=True) \"\"\" try: rospy.spin() except KeyboardInterrupt: print(\"Shutting down\") cv2.destroyAllWindows()","image_converter() rospy.init_node('image_converter', anonymous=True) \"\"\" try: rospy.spin() except KeyboardInterrupt: print(\"Shutting down\") cv2.destroyAllWindows() \"\"\" if","print_function import roslib roslib.load_manifest('msgs_to_cv2') import sys import rospy import cv2 from std_msgs.msg import","python from __future__ import print_function import roslib roslib.load_manifest('msgs_to_cv2') import sys import rospy import","main(args): while True: ic = image_converter() rospy.init_node('image_converter', anonymous=True) \"\"\" try: rospy.spin() except KeyboardInterrupt:","self.image_sub = rospy.Subscriber(\"/bebop/image_raw\",Image,self.callback) def callback(self,data): try: cv_image = self.bridge.imgmsg_to_cv2(data, \"bgr8\") except CvBridgeError as","#!/usr/bin/env python from __future__ import print_function import roslib roslib.load_manifest('msgs_to_cv2') import sys import rospy","image_converter: def __init__(self): self.bridge = CvBridge() self.image_sub = rospy.Subscriber(\"/bebop/image_raw\",Image,self.callback) def callback(self,data): try: cv_image","from sensor_msgs.msg import Image from cv_bridge import CvBridge, CvBridgeError class image_converter: def __init__(self):","from cv_bridge import CvBridge, CvBridgeError class image_converter: def __init__(self): self.bridge = CvBridge() self.image_sub","sensor_msgs.msg import Image from cv_bridge import CvBridge, CvBridgeError class image_converter: def __init__(self): self.bridge","__future__ import print_function import roslib roslib.load_manifest('msgs_to_cv2') import sys import rospy import cv2 from","import roslib roslib.load_manifest('msgs_to_cv2') import sys import rospy import cv2 from std_msgs.msg import String","Image from cv_bridge import CvBridge, CvBridgeError class image_converter: def __init__(self): self.bridge = CvBridge()","self.bridge.imgmsg_to_cv2(data, \"bgr8\") except CvBridgeError as e: print(e) cv2.imshow(\"hola\", cv_image) cv2.waitKey(3) def main(args): while","cv_image) cv2.waitKey(3) def main(args): while True: ic = image_converter() rospy.init_node('image_converter', anonymous=True) \"\"\" try:","except CvBridgeError as e: print(e) cv2.imshow(\"hola\", cv_image) cv2.waitKey(3) def main(args): while True: ic","def __init__(self): self.bridge = CvBridge() self.image_sub = rospy.Subscriber(\"/bebop/image_raw\",Image,self.callback) def callback(self,data): try: cv_image =","from __future__ import print_function import roslib roslib.load_manifest('msgs_to_cv2') import sys import rospy import cv2","import cv2 from std_msgs.msg import String from sensor_msgs.msg import Image from cv_bridge import","= CvBridge() self.image_sub = rospy.Subscriber(\"/bebop/image_raw\",Image,self.callback) def callback(self,data): try: cv_image = self.bridge.imgmsg_to_cv2(data, \"bgr8\") except","CvBridge, CvBridgeError class image_converter: def __init__(self): self.bridge = CvBridge() self.image_sub = rospy.Subscriber(\"/bebop/image_raw\",Image,self.callback) def","cv_image = self.bridge.imgmsg_to_cv2(data, \"bgr8\") except CvBridgeError as e: print(e) cv2.imshow(\"hola\", cv_image) cv2.waitKey(3) def","print(e) cv2.imshow(\"hola\", cv_image) cv2.waitKey(3) def main(args): while True: ic = image_converter() rospy.init_node('image_converter', anonymous=True)","cv_bridge import CvBridge, CvBridgeError class image_converter: def __init__(self): self.bridge = CvBridge() self.image_sub =","import Image from cv_bridge import CvBridge, CvBridgeError class image_converter: def __init__(self): self.bridge =","__init__(self): self.bridge = CvBridge() self.image_sub = rospy.Subscriber(\"/bebop/image_raw\",Image,self.callback) def callback(self,data): try: cv_image = self.bridge.imgmsg_to_cv2(data,","rospy.Subscriber(\"/bebop/image_raw\",Image,self.callback) def callback(self,data): try: cv_image = self.bridge.imgmsg_to_cv2(data, \"bgr8\") except CvBridgeError as e: print(e)","try: rospy.spin() except KeyboardInterrupt: print(\"Shutting down\") cv2.destroyAllWindows() \"\"\" if __name__ == '__main__': main(sys.argv)","sys import rospy import cv2 from std_msgs.msg import String from sensor_msgs.msg import Image","as e: print(e) cv2.imshow(\"hola\", cv_image) cv2.waitKey(3) def main(args): while True: ic = image_converter()","String from sensor_msgs.msg import Image from cv_bridge import CvBridge, CvBridgeError class image_converter: def","import CvBridge, CvBridgeError class image_converter: def __init__(self): self.bridge = CvBridge() self.image_sub = rospy.Subscriber(\"/bebop/image_raw\",Image,self.callback)","def callback(self,data): try: cv_image = self.bridge.imgmsg_to_cv2(data, \"bgr8\") except CvBridgeError as e: print(e) cv2.imshow(\"hola\",","CvBridgeError as e: print(e) cv2.imshow(\"hola\", cv_image) cv2.waitKey(3) def main(args): while True: ic =","class image_converter: def __init__(self): self.bridge = CvBridge() self.image_sub = rospy.Subscriber(\"/bebop/image_raw\",Image,self.callback) def callback(self,data): try:","e: print(e) cv2.imshow(\"hola\", cv_image) cv2.waitKey(3) def main(args): while True: ic = image_converter() rospy.init_node('image_converter',","while True: ic = image_converter() rospy.init_node('image_converter', anonymous=True) \"\"\" try: rospy.spin() except KeyboardInterrupt: print(\"Shutting","= image_converter() rospy.init_node('image_converter', anonymous=True) \"\"\" try: rospy.spin() except KeyboardInterrupt: print(\"Shutting down\") cv2.destroyAllWindows() \"\"\"","anonymous=True) \"\"\" try: rospy.spin() except KeyboardInterrupt: print(\"Shutting down\") cv2.destroyAllWindows() \"\"\" if __name__ ==","roslib.load_manifest('msgs_to_cv2') import sys import rospy import cv2 from std_msgs.msg import String from sensor_msgs.msg","import sys import rospy import cv2 from std_msgs.msg import String from sensor_msgs.msg import","CvBridgeError class image_converter: def __init__(self): self.bridge = CvBridge() self.image_sub = rospy.Subscriber(\"/bebop/image_raw\",Image,self.callback) def callback(self,data):","self.bridge = CvBridge() self.image_sub = rospy.Subscriber(\"/bebop/image_raw\",Image,self.callback) def callback(self,data): try: cv_image = self.bridge.imgmsg_to_cv2(data, \"bgr8\")","import print_function import roslib roslib.load_manifest('msgs_to_cv2') import sys import rospy import cv2 from std_msgs.msg","cv2.waitKey(3) def main(args): while True: ic = image_converter() rospy.init_node('image_converter', anonymous=True) \"\"\" try: rospy.spin()","cv2 from std_msgs.msg import String from sensor_msgs.msg import Image from cv_bridge import CvBridge,","\"\"\" try: rospy.spin() except KeyboardInterrupt: print(\"Shutting down\") cv2.destroyAllWindows() \"\"\" if __name__ == '__main__':","rospy.init_node('image_converter', anonymous=True) \"\"\" try: rospy.spin() except KeyboardInterrupt: print(\"Shutting down\") cv2.destroyAllWindows() \"\"\" if __name__","callback(self,data): try: cv_image = self.bridge.imgmsg_to_cv2(data, \"bgr8\") except CvBridgeError as e: print(e) cv2.imshow(\"hola\", cv_image)","from std_msgs.msg import String from sensor_msgs.msg import Image from cv_bridge import CvBridge, CvBridgeError","std_msgs.msg import String from sensor_msgs.msg import Image from cv_bridge import CvBridge, CvBridgeError class","= rospy.Subscriber(\"/bebop/image_raw\",Image,self.callback) def callback(self,data): try: cv_image = self.bridge.imgmsg_to_cv2(data, \"bgr8\") except CvBridgeError as e:","rospy import cv2 from std_msgs.msg import String from sensor_msgs.msg import Image from cv_bridge","\"bgr8\") except CvBridgeError as e: print(e) cv2.imshow(\"hola\", cv_image) cv2.waitKey(3) def main(args): while True:","True: ic = image_converter() rospy.init_node('image_converter', anonymous=True) \"\"\" try: rospy.spin() except KeyboardInterrupt: print(\"Shutting down\")","import String from sensor_msgs.msg import Image from cv_bridge import CvBridge, CvBridgeError class image_converter:","def main(args): while True: ic = image_converter() rospy.init_node('image_converter', anonymous=True) \"\"\" try: rospy.spin() except","roslib roslib.load_manifest('msgs_to_cv2') import sys import rospy import cv2 from std_msgs.msg import String from","= self.bridge.imgmsg_to_cv2(data, \"bgr8\") except CvBridgeError as e: print(e) cv2.imshow(\"hola\", cv_image) cv2.waitKey(3) def main(args):","try: cv_image = self.bridge.imgmsg_to_cv2(data, \"bgr8\") except CvBridgeError as e: print(e) cv2.imshow(\"hola\", cv_image) cv2.waitKey(3)","<gh_stars>0 #!/usr/bin/env python from __future__ import print_function import roslib roslib.load_manifest('msgs_to_cv2') import sys import"],"string":"[\n \"CvBridge() self.image_sub = rospy.Subscriber(\\\"/bebop/image_raw\\\",Image,self.callback) def callback(self,data): try: cv_image = self.bridge.imgmsg_to_cv2(data, \\\"bgr8\\\") except CvBridgeError\",\n \"cv2.imshow(\\\"hola\\\", cv_image) cv2.waitKey(3) def main(args): while True: ic = image_converter() rospy.init_node('image_converter', anonymous=True) \\\"\\\"\\\"\",\n \"import rospy import cv2 from std_msgs.msg import String from sensor_msgs.msg import Image from\",\n \"ic = image_converter() rospy.init_node('image_converter', anonymous=True) \\\"\\\"\\\" try: rospy.spin() except KeyboardInterrupt: print(\\\"Shutting down\\\") cv2.destroyAllWindows()\",\n \"image_converter() rospy.init_node('image_converter', anonymous=True) \\\"\\\"\\\" try: rospy.spin() except KeyboardInterrupt: print(\\\"Shutting down\\\") cv2.destroyAllWindows() \\\"\\\"\\\" if\",\n \"print_function import roslib roslib.load_manifest('msgs_to_cv2') import sys import rospy import cv2 from std_msgs.msg import\",\n \"python from __future__ import print_function import roslib roslib.load_manifest('msgs_to_cv2') import sys import rospy import\",\n \"main(args): while True: ic = image_converter() rospy.init_node('image_converter', anonymous=True) \\\"\\\"\\\" try: rospy.spin() except KeyboardInterrupt:\",\n \"self.image_sub = rospy.Subscriber(\\\"/bebop/image_raw\\\",Image,self.callback) def callback(self,data): try: cv_image = self.bridge.imgmsg_to_cv2(data, \\\"bgr8\\\") except CvBridgeError as\",\n \"#!/usr/bin/env python from __future__ import print_function import roslib roslib.load_manifest('msgs_to_cv2') import sys import rospy\",\n \"image_converter: def __init__(self): self.bridge = CvBridge() self.image_sub = rospy.Subscriber(\\\"/bebop/image_raw\\\",Image,self.callback) def callback(self,data): try: cv_image\",\n \"from sensor_msgs.msg import Image from cv_bridge import CvBridge, CvBridgeError class image_converter: def __init__(self):\",\n \"from cv_bridge import CvBridge, CvBridgeError class image_converter: def __init__(self): self.bridge = CvBridge() self.image_sub\",\n \"sensor_msgs.msg import Image from cv_bridge import CvBridge, CvBridgeError class image_converter: def __init__(self): self.bridge\",\n \"__future__ import print_function import roslib roslib.load_manifest('msgs_to_cv2') import sys import rospy import cv2 from\",\n \"import roslib roslib.load_manifest('msgs_to_cv2') import sys import rospy import cv2 from std_msgs.msg import String\",\n \"Image from cv_bridge import CvBridge, CvBridgeError class image_converter: def __init__(self): self.bridge = CvBridge()\",\n \"self.bridge.imgmsg_to_cv2(data, \\\"bgr8\\\") except CvBridgeError as e: print(e) cv2.imshow(\\\"hola\\\", cv_image) cv2.waitKey(3) def main(args): while\",\n \"cv_image) cv2.waitKey(3) def main(args): while True: ic = image_converter() rospy.init_node('image_converter', anonymous=True) \\\"\\\"\\\" try:\",\n \"except CvBridgeError as e: print(e) cv2.imshow(\\\"hola\\\", cv_image) cv2.waitKey(3) def main(args): while True: ic\",\n \"def __init__(self): self.bridge = CvBridge() self.image_sub = rospy.Subscriber(\\\"/bebop/image_raw\\\",Image,self.callback) def callback(self,data): try: cv_image =\",\n \"from __future__ import print_function import roslib roslib.load_manifest('msgs_to_cv2') import sys import rospy import cv2\",\n \"import cv2 from std_msgs.msg import String from sensor_msgs.msg import Image from cv_bridge import\",\n \"= CvBridge() self.image_sub = rospy.Subscriber(\\\"/bebop/image_raw\\\",Image,self.callback) def callback(self,data): try: cv_image = self.bridge.imgmsg_to_cv2(data, \\\"bgr8\\\") except\",\n \"CvBridge, CvBridgeError class image_converter: def __init__(self): self.bridge = CvBridge() self.image_sub = rospy.Subscriber(\\\"/bebop/image_raw\\\",Image,self.callback) def\",\n \"cv_image = self.bridge.imgmsg_to_cv2(data, \\\"bgr8\\\") except CvBridgeError as e: print(e) cv2.imshow(\\\"hola\\\", cv_image) cv2.waitKey(3) def\",\n \"print(e) cv2.imshow(\\\"hola\\\", cv_image) cv2.waitKey(3) def main(args): while True: ic = image_converter() rospy.init_node('image_converter', anonymous=True)\",\n \"cv_bridge import CvBridge, CvBridgeError class image_converter: def __init__(self): self.bridge = CvBridge() self.image_sub =\",\n \"import Image from cv_bridge import CvBridge, CvBridgeError class image_converter: def __init__(self): self.bridge =\",\n \"__init__(self): self.bridge = CvBridge() self.image_sub = rospy.Subscriber(\\\"/bebop/image_raw\\\",Image,self.callback) def callback(self,data): try: cv_image = self.bridge.imgmsg_to_cv2(data,\",\n \"rospy.Subscriber(\\\"/bebop/image_raw\\\",Image,self.callback) def callback(self,data): try: cv_image = self.bridge.imgmsg_to_cv2(data, \\\"bgr8\\\") except CvBridgeError as e: print(e)\",\n \"try: rospy.spin() except KeyboardInterrupt: print(\\\"Shutting down\\\") cv2.destroyAllWindows() \\\"\\\"\\\" if __name__ == '__main__': main(sys.argv)\",\n \"sys import rospy import cv2 from std_msgs.msg import String from sensor_msgs.msg import Image\",\n \"as e: print(e) cv2.imshow(\\\"hola\\\", cv_image) cv2.waitKey(3) def main(args): while True: ic = image_converter()\",\n \"String from sensor_msgs.msg import Image from cv_bridge import CvBridge, CvBridgeError class image_converter: def\",\n \"import CvBridge, CvBridgeError class image_converter: def __init__(self): self.bridge = CvBridge() self.image_sub = rospy.Subscriber(\\\"/bebop/image_raw\\\",Image,self.callback)\",\n \"def callback(self,data): try: cv_image = self.bridge.imgmsg_to_cv2(data, \\\"bgr8\\\") except CvBridgeError as e: print(e) cv2.imshow(\\\"hola\\\",\",\n \"CvBridgeError as e: print(e) cv2.imshow(\\\"hola\\\", cv_image) cv2.waitKey(3) def main(args): while True: ic =\",\n \"class image_converter: def __init__(self): self.bridge = CvBridge() self.image_sub = rospy.Subscriber(\\\"/bebop/image_raw\\\",Image,self.callback) def callback(self,data): try:\",\n \"e: print(e) cv2.imshow(\\\"hola\\\", cv_image) cv2.waitKey(3) def main(args): while True: ic = image_converter() rospy.init_node('image_converter',\",\n \"while True: ic = image_converter() rospy.init_node('image_converter', anonymous=True) \\\"\\\"\\\" try: rospy.spin() except KeyboardInterrupt: print(\\\"Shutting\",\n \"= image_converter() rospy.init_node('image_converter', anonymous=True) \\\"\\\"\\\" try: rospy.spin() except KeyboardInterrupt: print(\\\"Shutting down\\\") cv2.destroyAllWindows() \\\"\\\"\\\"\",\n \"anonymous=True) \\\"\\\"\\\" try: rospy.spin() except KeyboardInterrupt: print(\\\"Shutting down\\\") cv2.destroyAllWindows() \\\"\\\"\\\" if __name__ ==\",\n \"roslib.load_manifest('msgs_to_cv2') import sys import rospy import cv2 from std_msgs.msg import String from sensor_msgs.msg\",\n \"import sys import rospy import cv2 from std_msgs.msg import String from sensor_msgs.msg import\",\n \"CvBridgeError class image_converter: def __init__(self): self.bridge = CvBridge() self.image_sub = rospy.Subscriber(\\\"/bebop/image_raw\\\",Image,self.callback) def callback(self,data):\",\n \"self.bridge = CvBridge() self.image_sub = rospy.Subscriber(\\\"/bebop/image_raw\\\",Image,self.callback) def callback(self,data): try: cv_image = self.bridge.imgmsg_to_cv2(data, \\\"bgr8\\\")\",\n \"import print_function import roslib roslib.load_manifest('msgs_to_cv2') import sys import rospy import cv2 from std_msgs.msg\",\n \"cv2.waitKey(3) def main(args): while True: ic = image_converter() rospy.init_node('image_converter', anonymous=True) \\\"\\\"\\\" try: rospy.spin()\",\n \"cv2 from std_msgs.msg import String from sensor_msgs.msg import Image from cv_bridge import CvBridge,\",\n \"\\\"\\\"\\\" try: rospy.spin() except KeyboardInterrupt: print(\\\"Shutting down\\\") cv2.destroyAllWindows() \\\"\\\"\\\" if __name__ == '__main__':\",\n \"rospy.init_node('image_converter', anonymous=True) \\\"\\\"\\\" try: rospy.spin() except KeyboardInterrupt: print(\\\"Shutting down\\\") cv2.destroyAllWindows() \\\"\\\"\\\" if __name__\",\n \"callback(self,data): try: cv_image = self.bridge.imgmsg_to_cv2(data, \\\"bgr8\\\") except CvBridgeError as e: print(e) cv2.imshow(\\\"hola\\\", cv_image)\",\n \"from std_msgs.msg import String from sensor_msgs.msg import Image from cv_bridge import CvBridge, CvBridgeError\",\n \"std_msgs.msg import String from sensor_msgs.msg import Image from cv_bridge import CvBridge, CvBridgeError class\",\n \"= rospy.Subscriber(\\\"/bebop/image_raw\\\",Image,self.callback) def callback(self,data): try: cv_image = self.bridge.imgmsg_to_cv2(data, \\\"bgr8\\\") except CvBridgeError as e:\",\n \"rospy import cv2 from std_msgs.msg import String from sensor_msgs.msg import Image from cv_bridge\",\n \"\\\"bgr8\\\") except CvBridgeError as e: print(e) cv2.imshow(\\\"hola\\\", cv_image) cv2.waitKey(3) def main(args): while True:\",\n \"True: ic = image_converter() rospy.init_node('image_converter', anonymous=True) \\\"\\\"\\\" try: rospy.spin() except KeyboardInterrupt: print(\\\"Shutting down\\\")\",\n \"import String from sensor_msgs.msg import Image from cv_bridge import CvBridge, CvBridgeError class image_converter:\",\n \"def main(args): while True: ic = image_converter() rospy.init_node('image_converter', anonymous=True) \\\"\\\"\\\" try: rospy.spin() except\",\n \"roslib roslib.load_manifest('msgs_to_cv2') import sys import rospy import cv2 from std_msgs.msg import String from\",\n \"= self.bridge.imgmsg_to_cv2(data, \\\"bgr8\\\") except CvBridgeError as e: print(e) cv2.imshow(\\\"hola\\\", cv_image) cv2.waitKey(3) def main(args):\",\n \"try: cv_image = self.bridge.imgmsg_to_cv2(data, \\\"bgr8\\\") except CvBridgeError as e: print(e) cv2.imshow(\\\"hola\\\", cv_image) cv2.waitKey(3)\",\n \"<gh_stars>0 #!/usr/bin/env python from __future__ import print_function import roslib roslib.load_manifest('msgs_to_cv2') import sys import\"\n]","isConversational":false}}},{"rowIdx":4498,"cells":{"ngram":{"kind":"list like","value":["Food-X Technologies # # This file is part of foodx_devops_tools. # # You","Copyright (c) 2021 Food-X Technologies # # This file is part of foodx_devops_tools.","a copy of the MIT License along with # foodx_devops_tools. If not, see","file is part of foodx_devops_tools. # # You should have received a copy","# # This file is part of foodx_devops_tools. # # You should have","Technologies # # This file is part of foodx_devops_tools. # # You should","received a copy of the MIT License along with # foodx_devops_tools. If not,","have received a copy of the MIT License along with # foodx_devops_tools. If","foodx_devops_tools. # # You should have received a copy of the MIT License","should have received a copy of the MIT License along with # foodx_devops_tools.","copy of the MIT License along with # foodx_devops_tools. If not, see <https://opensource.org/licenses/MIT>.","2021 Food-X Technologies # # This file is part of foodx_devops_tools. # #","of the MIT License along with # foodx_devops_tools. If not, see <https://opensource.org/licenses/MIT>. \"\"\"Azure","of foodx_devops_tools. # # You should have received a copy of the MIT","is part of foodx_devops_tools. # # You should have received a copy of","the MIT License along with # foodx_devops_tools. If not, see <https://opensource.org/licenses/MIT>. \"\"\"Azure related","This file is part of foodx_devops_tools. # # You should have received a","part of foodx_devops_tools. # # You should have received a copy of the","# # You should have received a copy of the MIT License along","# You should have received a copy of the MIT License along with","# Copyright (c) 2021 Food-X Technologies # # This file is part of","MIT License along with # foodx_devops_tools. If not, see <https://opensource.org/licenses/MIT>. \"\"\"Azure related utilities.\"\"\"","You should have received a copy of the MIT License along with #","# This file is part of foodx_devops_tools. # # You should have received","(c) 2021 Food-X Technologies # # This file is part of foodx_devops_tools. #","<reponame>Food-X-Technologies/foodx_devops_tools<filename>foodx_devops_tools/azure/__init__.py # Copyright (c) 2021 Food-X Technologies # # This file is part"],"string":"[\n \"Food-X Technologies # # This file is part of foodx_devops_tools. # # You\",\n \"Copyright (c) 2021 Food-X Technologies # # This file is part of foodx_devops_tools.\",\n \"a copy of the MIT License along with # foodx_devops_tools. If not, see\",\n \"file is part of foodx_devops_tools. # # You should have received a copy\",\n \"# # This file is part of foodx_devops_tools. # # You should have\",\n \"Technologies # # This file is part of foodx_devops_tools. # # You should\",\n \"received a copy of the MIT License along with # foodx_devops_tools. If not,\",\n \"have received a copy of the MIT License along with # foodx_devops_tools. If\",\n \"foodx_devops_tools. # # You should have received a copy of the MIT License\",\n \"should have received a copy of the MIT License along with # foodx_devops_tools.\",\n \"copy of the MIT License along with # foodx_devops_tools. If not, see <https://opensource.org/licenses/MIT>.\",\n \"2021 Food-X Technologies # # This file is part of foodx_devops_tools. # #\",\n \"of the MIT License along with # foodx_devops_tools. If not, see <https://opensource.org/licenses/MIT>. \\\"\\\"\\\"Azure\",\n \"of foodx_devops_tools. # # You should have received a copy of the MIT\",\n \"is part of foodx_devops_tools. # # You should have received a copy of\",\n \"the MIT License along with # foodx_devops_tools. If not, see <https://opensource.org/licenses/MIT>. \\\"\\\"\\\"Azure related\",\n \"This file is part of foodx_devops_tools. # # You should have received a\",\n \"part of foodx_devops_tools. # # You should have received a copy of the\",\n \"# # You should have received a copy of the MIT License along\",\n \"# You should have received a copy of the MIT License along with\",\n \"# Copyright (c) 2021 Food-X Technologies # # This file is part of\",\n \"MIT License along with # foodx_devops_tools. If not, see <https://opensource.org/licenses/MIT>. \\\"\\\"\\\"Azure related utilities.\\\"\\\"\\\"\",\n \"You should have received a copy of the MIT License along with #\",\n \"# This file is part of foodx_devops_tools. # # You should have received\",\n \"(c) 2021 Food-X Technologies # # This file is part of foodx_devops_tools. #\",\n \"<reponame>Food-X-Technologies/foodx_devops_tools<filename>foodx_devops_tools/azure/__init__.py # Copyright (c) 2021 Food-X Technologies # # This file is part\"\n]","isConversational":false}}},{"rowIdx":4499,"cells":{"ngram":{"kind":"list like","value":["IMPORTS }.................... #!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! # WARNING: To avoid polluting the public module namespace, external","this is probably actually useless. # #Nonetheless, the idea itself is trivial. We","#* Each __class_getitem__() dunder method of each \"_BeartypeValidatorFactoryABC\" subclass will need # to","instantiating these private factory classes. Is = _IsFactory(basename='Is') IsAttr = _IsAttrFactory(basename='IsAttr') IsEqual =","or more subscriptions of classes declared by this submodule. ''' # ....................{ IMPORTS","constraints # * IdenticalTo. # * NotIdenticalTo. # * LessThan. # * GreaterThan.","NonEmptyString) -> str: ... # #So what's the difference between \"typing.Annotated\" and \"beartype.is.Portable\"","argparse import ArgumentParser as _ArgumentParser\" rather # than merely \"from argparse import ArgumentParser\").","NonEmptyString = Portable[str, NonEmptyStringTest] # @beartype # def munge_it(text: NonEmptyString) -> str: ...","# def __isinstancecheck__(cls, obj) -> bool: # return isinstance(obj, str) and NonEmptyStringTest(obj) #*","new #\"beartype.is.Portable\" singleton accessed in the same way: e.g., # from beartype import","subscriptable (indexable) classes enabling callers to validate the internal structure of arbitrarily complex","above for safety. del ( _IsFactory, _IsAttrFactory, _IsEqualFactory, _IsInstanceFactory, _IsSubclassFactory, ) # ....................{","it seems doubtful anyone #would actually do that. Nonetheless, that's food for thought","this implies that: #* The BeartypeValidator.__init__() method will need to additionally accept a","}.................... #FIXME: As intelligently requested by @Saphyel at #32, add support for #additional","what's the difference between \"typing.Annotated\" and \"beartype.is.Portable\" #then? Simple. The latter dynamically generates","accept a new # mandatory \"get_cause_or_none: Callable[[], Optional[str]]\" parameter, which # that method","the existing CauseSleuth.get_cause_or_none() #method. This new BeartypeValidator.get_cause_or_none() method should then be #called by","We declare a new #\"beartype.is.Portable\" singleton accessed in the same way: e.g., #","Simple. The latter dynamically generates one new PEP 3119-compliant #metaclass and associated class","#FIXME: Add a new BeartypeValidator.get_cause_or_none() method with the same #signature and docstring as","NonEmptyStringClass(object, metaclass=NonEmptyStringMetaclass): # pass # #Well, so much for brilliant. It's slow and","then localize to \"self.get_cause_or_none\". #* Each __class_getitem__() dunder method of each \"_BeartypeValidatorFactoryABC\" subclass","( _IsFactory, _IsAttrFactory, _IsEqualFactory, _IsInstanceFactory, _IsSubclassFactory, ) # ....................{ TODO }.................... #FIXME: As","to validate the internal structure of arbitrarily complex scalars, data structures, and third-party",":attr:`typing.Union`), these classes dynamically generate PEP-compliant type hints when subscripted (indexed) and are","that: #* The BeartypeValidator.__init__() method will need to additionally accept a new #","using a runtime type #checker, you're probably *ONLY* using beartype. Right? That said,","* GreaterThan. # * Range. # * DivisibleBy. #FIXME: Add a new BeartypeValidator.get_cause_or_none()","Is[lambda text: bool(text)] # NonEmptyString = Portable[str, NonEmptyStringTest] # @beartype # def munge_it(text:","(indexable) classes enabling callers to validate the internal structure of arbitrarily complex scalars,","__isinstancecheck__() # dunder method. For the above example, this would be: # class","beartype.is import Portable # NonEmptyStringTest = Is[lambda text: bool(text)] # NonEmptyString = Portable[str,","slow and big, so it seems doubtful anyone #would actually do that. Nonetheless,","This submodule publishes a PEP-compliant hierarchy of subscriptable (indexable) classes enabling callers to","#* String constraints: # * Email. # * Uuid. # * Choice. #","module scope *ONLY* under alternate private # names (e.g., \"from argparse import ArgumentParser","callables and variables. Unlike annotation objects defined by the :mod:`typing` module, these classes","expected to (in order): #. Annotate callable parameters and returns to be validated","rather # than merely \"from argparse import ArgumentParser\"). #!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! from beartype.vale._is._valeis import _IsFactory","bool(text)]]\") are only supported by beartype #itself. Of course, does anyone care? I","*not* directly usable as annotations. Instead, callers are expected to (in order): #.","* Locale. # * Country. # * Currency. #* Comparison constraints # *","Choice. # * Language. # * Locale. # * Country. # * Currency.","import ArgumentParser as _ArgumentParser\" rather # than merely \"from argparse import ArgumentParser\"). #!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!","subscripted. Clearly, this gets #expensive in both space and time consumption fast --","need to additionally accept a new # mandatory \"get_cause_or_none: Callable[[], Optional[str]]\" parameter, which","}.................... #!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! # WARNING: To avoid polluting the public module namespace, external attributes",":mod:`typing` module, these classes are *not* explicitly covered by existing PEPs and thus","of \"Is\" (e.g., #\"Annotated[str, Is[lambda text: bool(text)]]\") are only supported by beartype #itself.","# * Currency. #* Comparison constraints # * IdenticalTo. # * NotIdenticalTo. #","#additional classes support constraints resembling: # #* String constraints: # * Email. #","subscriptions of \"Is\" (e.g., #\"Annotated[str, Is[lambda text: bool(text)]]\") are only supported by beartype","since they'd still have to import beartype #infrastructure to do so. So, this","in the same way: e.g., # from beartype import beartype # from beartype.is","new class would then be entirely empty. For the above example, this #","\"BeartypeValidator\" instance. #FIXME: *BRILLIANT IDEA.* Holyshitballstime. The idea here is that we can","consumption fast -- which is why this won't #be the default approach. For","* Range. # * DivisibleBy. #FIXME: Add a new BeartypeValidator.get_cause_or_none() method with the","and pass that callable when creating and returning # its \"BeartypeValidator\" instance. #FIXME:","its \"BeartypeValidator\" instance. #FIXME: *BRILLIANT IDEA.* Holyshitballstime. The idea here is that we","#expensive in both space and time consumption fast -- which is why this","subclass will need # to additionally define and pass that callable when creating","# NonEmptyString = Portable[str, NonEmptyStringTest] # @beartype # def munge_it(text: NonEmptyString) -> str:","_IsEqualFactory, _IsInstanceFactory, _IsSubclassFactory, ) # ....................{ TODO }.................... #FIXME: As intelligently requested by","Instead, callers are expected to (in order): #. Annotate callable parameters and returns","and associated class whenever subscripted. Clearly, this gets #expensive in both space and","dynamically #synthesize PEP-compliant type hints that would then be implicitly supported by #any","# * LessThan. # * GreaterThan. # * Range. # * DivisibleBy. #FIXME:","that would then be implicitly supported by #any runtime type checker. At present,","(e.g., #\"Annotated[str, Is[lambda text: bool(text)]]\") are only supported by beartype #itself. Of course,","is probably actually useless. # #Nonetheless, the idea itself is trivial. We declare","# class NonEmptyStringClass(object, metaclass=NonEmptyStringMetaclass): # pass # #Well, so much for brilliant. It's","The type of those parameters and returns. #. One or more subscriptions of","@beartype # def munge_it(text: NonEmptyString) -> str: ... # #So what's the difference","#. Subscript those hints with (in order): #. The type of those parameters","annotations. Instead, callers are expected to (in order): #. Annotate callable parameters and","e.g., # from beartype import beartype # from beartype.is import Portable # NonEmptyStringTest","declare a new #\"beartype.is.Portable\" singleton accessed in the same way: e.g., # from","callers are expected to (in order): #. Annotate callable parameters and returns to","from beartype.is import Portable # NonEmptyStringTest = Is[lambda text: bool(text)] # NonEmptyString =","this won't #be the default approach. For safety, this new class does *NOT*","Holyshitballstime. The idea here is that we can #leverage all of our existing","dynamically generates one new PEP 3119-compliant #metaclass and associated class whenever subscripted. Clearly,","# * Language. # * Locale. # * Country. # * Currency. #*","structure of arbitrarily complex scalars, data structures, and third-party objects. Like annotation objects","del ( _IsFactory, _IsAttrFactory, _IsEqualFactory, _IsInstanceFactory, _IsSubclassFactory, ) # ....................{ TODO }.................... #FIXME:","human-readable #exception messages. Note that this implies that: #* The BeartypeValidator.__init__() method will","need # to additionally define and pass that callable when creating and returning","you're probably *ONLY* using beartype. Right? That said, this would #technically improve portability","data structures, and third-party objects. Like annotation objects defined by the :mod:`typing` module","be #called by the \"_peperrorannotated\" submodule to generate human-readable #exception messages. Note that","# * Locale. # * Country. # * Currency. #* Comparison constraints #","\"get_cause_or_none: Callable[[], Optional[str]]\" parameter, which # that method should then localize to \"self.get_cause_or_none\".","much for brilliant. It's slow and big, so it seems doubtful anyone #would","dunder method. For the above example, this would be: # class NonEmptyStringMetaclass(object): #","Portable # NonEmptyStringTest = Is[lambda text: bool(text)] # NonEmptyString = Portable[str, NonEmptyStringTest] #","are expected to (in order): #. Annotate callable parameters and returns to be","class does *NOT* subclass the #first subscripted class. Instead: #* This new metaclass","dunder method of each \"_BeartypeValidatorFactoryABC\" subclass will need # to additionally define and","if you're using a runtime type #checker, you're probably *ONLY* using beartype. Right?","checker. At present, subscriptions of \"Is\" (e.g., #\"Annotated[str, Is[lambda text: bool(text)]]\") are only","infrastructure to dynamically #synthesize PEP-compliant type hints that would then be implicitly supported","the \"_peperrorannotated\" submodule to generate human-readable #exception messages. Note that this implies that:","simply defines an __isinstancecheck__() # dunder method. For the above example, this would","One or more subscriptions of classes declared by this submodule. ''' # ....................{","Optional[str]]\" parameter, which # that method should then localize to \"self.get_cause_or_none\". #* Each","care? I mean, if you're using a runtime type #checker, you're probably *ONLY*","The idea here is that we can #leverage all of our existing \"beartype.is\"","names (e.g., \"from argparse import ArgumentParser as _ArgumentParser\" rather # than merely \"from","factory singletons instantiating these private factory classes. Is = _IsFactory(basename='Is') IsAttr = _IsAttrFactory(basename='IsAttr')","#. One or more subscriptions of classes declared by this submodule. ''' #","latter dynamically generates one new PEP 3119-compliant #metaclass and associated class whenever subscripted.","_IsInstanceFactory(basename='IsInstance') IsSubclass = _IsSubclassFactory(basename='IsSubclass') # Delete all private factory classes imported above for","attributes # should be locally imported at module scope *ONLY* under alternate private","#So what's the difference between \"typing.Annotated\" and \"beartype.is.Portable\" #then? Simple. The latter dynamically",":pep:`593`-compliant :attr:`typing.Annotated` type hints. #. Subscript those hints with (in order): #. The","import _IsFactory from beartype.vale._is._valeistype import ( _IsInstanceFactory, _IsSubclassFactory, ) from beartype.vale._is._valeisobj import _IsAttrFactory","doubtful anyone #would actually do that. Nonetheless, that's food for thought for you.","# should be locally imported at module scope *ONLY* under alternate private #","class whenever subscripted. Clearly, this gets #expensive in both space and time consumption","_IsSubclassFactory(basename='IsSubclass') # Delete all private factory classes imported above for safety. del (","constraints: # * Email. # * Uuid. # * Choice. # * Language.","PEP-compliant type hints when subscripted (indexed) and are thus intended to annotate callables","defined by the :mod:`typing` module (e.g., :attr:`typing.Union`), these classes dynamically generate PEP-compliant type","anyone care? I mean, if you're using a runtime type #checker, you're probably","#exception messages. Note that this implies that: #* The BeartypeValidator.__init__() method will need","As intelligently requested by @Saphyel at #32, add support for #additional classes support","callers to validate the internal structure of arbitrarily complex scalars, data structures, and","arbitrarily complex scalars, data structures, and third-party objects. Like annotation objects defined by","# --------------------( LICENSE )-------------------- # Copyright (c) 2014-2021 Beartype authors. # See \"LICENSE\"","Is[lambda text: bool(text)]]\") are only supported by beartype #itself. Of course, does anyone","add support for #additional classes support constraints resembling: # #* String constraints: #","# * Country. # * Currency. #* Comparison constraints # * IdenticalTo. #","argparse import ArgumentParser\"). #!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! from beartype.vale._is._valeis import _IsFactory from beartype.vale._is._valeistype import ( _IsInstanceFactory,","why this won't #be the default approach. For safety, this new class does","For the above example, this # would be: # class NonEmptyStringClass(object, metaclass=NonEmptyStringMetaclass): #","\"from argparse import ArgumentParser\"). #!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! from beartype.vale._is._valeis import _IsFactory from beartype.vale._is._valeistype import (","def __isinstancecheck__(cls, obj) -> bool: # return isinstance(obj, str) and NonEmptyStringTest(obj) #* This","''' # ....................{ IMPORTS }.................... #!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! # WARNING: To avoid polluting the public","intended to annotate callables and variables. Unlike annotation objects defined by the :mod:`typing`","# * Email. # * Uuid. # * Choice. # * Language. #","of those parameters and returns. #. One or more subscriptions of classes declared","....................{ TODO }.................... #FIXME: As intelligently requested by @Saphyel at #32, add support","# to additionally define and pass that callable when creating and returning #","# * IdenticalTo. # * NotIdenticalTo. # * LessThan. # * GreaterThan. #","beartype. Right? That said, this would #technically improve portability by allowing users to","users to switch between different #checkers... except not really, since they'd still have","above example, this # would be: # class NonEmptyStringClass(object, metaclass=NonEmptyStringMetaclass): # pass #","--------------------( LICENSE )-------------------- # Copyright (c) 2014-2021 Beartype authors. # See \"LICENSE\" for","#called by the \"_peperrorannotated\" submodule to generate human-readable #exception messages. Note that this","by this submodule. ''' # ....................{ IMPORTS }.................... #!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! # WARNING: To avoid","would #technically improve portability by allowing users to switch between different #checkers... except","validate the internal structure of arbitrarily complex scalars, data structures, and third-party objects.","useless. # #Nonetheless, the idea itself is trivial. We declare a new #\"beartype.is.Portable\"","above example, this would be: # class NonEmptyStringMetaclass(object): # def __isinstancecheck__(cls, obj) ->","beartype #itself. Of course, does anyone care? I mean, if you're using a","structures, and third-party objects. Like annotation objects defined by the :mod:`typing` module (e.g.,","these private factory classes. Is = _IsFactory(basename='Is') IsAttr = _IsAttrFactory(basename='IsAttr') IsEqual = _IsEqualFactory(basename='IsEqual')","locally imported at module scope *ONLY* under alternate private # names (e.g., \"from","validators.** This submodule publishes a PEP-compliant hierarchy of subscriptable (indexable) classes enabling callers","DivisibleBy. #FIXME: Add a new BeartypeValidator.get_cause_or_none() method with the same #signature and docstring","Each __class_getitem__() dunder method of each \"_BeartypeValidatorFactoryABC\" subclass will need # to additionally","our existing \"beartype.is\" infrastructure to dynamically #synthesize PEP-compliant type hints that would then","class NonEmptyStringMetaclass(object): # def __isinstancecheck__(cls, obj) -> bool: # return isinstance(obj, str) and","and time consumption fast -- which is why this won't #be the default","new metaclass of this new class simply defines an __isinstancecheck__() # dunder method.","itself is trivial. We declare a new #\"beartype.is.Portable\" singleton accessed in the same","between \"typing.Annotated\" and \"beartype.is.Portable\" #then? Simple. The latter dynamically generates one new PEP","and big, so it seems doubtful anyone #would actually do that. Nonetheless, that's","_IsInstanceFactory, _IsSubclassFactory, ) # ....................{ TODO }.................... #FIXME: As intelligently requested by @Saphyel","#checker, you're probably *ONLY* using beartype. Right? That said, this would #technically improve","= _IsSubclassFactory(basename='IsSubclass') # Delete all private factory classes imported above for safety. del","the public module namespace, external attributes # should be locally imported at module","class simply defines an __isinstancecheck__() # dunder method. For the above example, this","by the :mod:`typing` module (e.g., :attr:`typing.Union`), these classes dynamically generate PEP-compliant type hints","#!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! from beartype.vale._is._valeis import _IsFactory from beartype.vale._is._valeistype import ( _IsInstanceFactory, _IsSubclassFactory, ) from","they'd still have to import beartype #infrastructure to do so. So, this is","will need # to additionally define and pass that callable when creating and","Of course, does anyone care? I mean, if you're using a runtime type","# ....................{ SINGLETONS }.................... # Public factory singletons instantiating these private factory classes.","a new BeartypeValidator.get_cause_or_none() method with the same #signature and docstring as the existing","_IsAttrFactory, _IsEqualFactory, _IsInstanceFactory, _IsSubclassFactory, ) # ....................{ TODO }.................... #FIXME: As intelligently requested","dynamically generate PEP-compliant type hints when subscripted (indexed) and are thus intended to","to \"self.get_cause_or_none\". #* Each __class_getitem__() dunder method of each \"_BeartypeValidatorFactoryABC\" subclass will need","#\"beartype.is.Portable\" singleton accessed in the same way: e.g., # from beartype import beartype","details. ''' **Beartype validators.** This submodule publishes a PEP-compliant hierarchy of subscriptable (indexable)","empty. For the above example, this # would be: # class NonEmptyStringClass(object, metaclass=NonEmptyStringMetaclass):","module namespace, external attributes # should be locally imported at module scope *ONLY*","still have to import beartype #infrastructure to do so. So, this is probably","trivial. We declare a new #\"beartype.is.Portable\" singleton accessed in the same way: e.g.,","imported at module scope *ONLY* under alternate private # names (e.g., \"from argparse","by the :mod:`typing` module, these classes are *not* explicitly covered by existing PEPs","and are thus intended to annotate callables and variables. Unlike annotation objects defined","= Portable[str, NonEmptyStringTest] # @beartype # def munge_it(text: NonEmptyString) -> str: ... #","associated class whenever subscripted. Clearly, this gets #expensive in both space and time","__class_getitem__() dunder method of each \"_BeartypeValidatorFactoryABC\" subclass will need # to additionally define","have to import beartype #infrastructure to do so. So, this is probably actually","directly usable as annotations. Instead, callers are expected to (in order): #. Annotate","intelligently requested by @Saphyel at #32, add support for #additional classes support constraints","#metaclass and associated class whenever subscripted. Clearly, this gets #expensive in both space",") # ....................{ TODO }.................... #FIXME: As intelligently requested by @Saphyel at #32,","_IsFactory(basename='Is') IsAttr = _IsAttrFactory(basename='IsAttr') IsEqual = _IsEqualFactory(basename='IsEqual') IsInstance = _IsInstanceFactory(basename='IsInstance') IsSubclass = _IsSubclassFactory(basename='IsSubclass')","said, this would #technically improve portability by allowing users to switch between different","namespace, external attributes # should be locally imported at module scope *ONLY* under","BeartypeValidator.get_cause_or_none() method with the same #signature and docstring as the existing CauseSleuth.get_cause_or_none() #method.","should then localize to \"self.get_cause_or_none\". #* Each __class_getitem__() dunder method of each \"_BeartypeValidatorFactoryABC\"","*NOT* subclass the #first subscripted class. Instead: #* This new metaclass of this","SINGLETONS }.................... # Public factory singletons instantiating these private factory classes. Is =","# Public factory singletons instantiating these private factory classes. Is = _IsFactory(basename='Is') IsAttr","Public factory singletons instantiating these private factory classes. Is = _IsFactory(basename='Is') IsAttr =","that method should then localize to \"self.get_cause_or_none\". #* Each __class_getitem__() dunder method of","to be validated with :pep:`593`-compliant :attr:`typing.Annotated` type hints. #. Subscript those hints with","#32, add support for #additional classes support constraints resembling: # #* String constraints:","IsSubclass = _IsSubclassFactory(basename='IsSubclass') # Delete all private factory classes imported above for safety.","#\"Annotated[str, Is[lambda text: bool(text)]]\") are only supported by beartype #itself. Of course, does","and NonEmptyStringTest(obj) #* This new class would then be entirely empty. For the","3119-compliant #metaclass and associated class whenever subscripted. Clearly, this gets #expensive in both","#!/usr/bin/env python3 # --------------------( LICENSE )-------------------- # Copyright (c) 2014-2021 Beartype authors. #","implicitly supported by #any runtime type checker. At present, subscriptions of \"Is\" (e.g.,","pass # #Well, so much for brilliant. It's slow and big, so it","# its \"BeartypeValidator\" instance. #FIXME: *BRILLIANT IDEA.* Holyshitballstime. The idea here is that","those parameters and returns. #. One or more subscriptions of classes declared by","To avoid polluting the public module namespace, external attributes # should be locally","Email. # * Uuid. # * Choice. # * Language. # * Locale.","then be #called by the \"_peperrorannotated\" submodule to generate human-readable #exception messages. Note","under alternate private # names (e.g., \"from argparse import ArgumentParser as _ArgumentParser\" rather","factory classes. Is = _IsFactory(basename='Is') IsAttr = _IsAttrFactory(basename='IsAttr') IsEqual = _IsEqualFactory(basename='IsEqual') IsInstance =","_IsAttrFactory(basename='IsAttr') IsEqual = _IsEqualFactory(basename='IsEqual') IsInstance = _IsInstanceFactory(basename='IsInstance') IsSubclass = _IsSubclassFactory(basename='IsSubclass') # Delete all","* DivisibleBy. #FIXME: Add a new BeartypeValidator.get_cause_or_none() method with the same #signature and","additionally define and pass that callable when creating and returning # its \"BeartypeValidator\"","classes enabling callers to validate the internal structure of arbitrarily complex scalars, data","of our existing \"beartype.is\" infrastructure to dynamically #synthesize PEP-compliant type hints that would","this would be: # class NonEmptyStringMetaclass(object): # def __isinstancecheck__(cls, obj) -> bool: #","Annotate callable parameters and returns to be validated with :pep:`593`-compliant :attr:`typing.Annotated` type hints.","Language. # * Locale. # * Country. # * Currency. #* Comparison constraints","returning # its \"BeartypeValidator\" instance. #FIXME: *BRILLIANT IDEA.* Holyshitballstime. The idea here is","covered by existing PEPs and thus *not* directly usable as annotations. Instead, callers","import beartype # from beartype.is import Portable # NonEmptyStringTest = Is[lambda text: bool(text)]","NonEmptyStringTest = Is[lambda text: bool(text)] # NonEmptyString = Portable[str, NonEmptyStringTest] # @beartype #","# NonEmptyStringTest = Is[lambda text: bool(text)] # NonEmptyString = Portable[str, NonEmptyStringTest] # @beartype","all of our existing \"beartype.is\" infrastructure to dynamically #synthesize PEP-compliant type hints that","class would then be entirely empty. For the above example, this # would","#. Annotate callable parameters and returns to be validated with :pep:`593`-compliant :attr:`typing.Annotated` type","be implicitly supported by #any runtime type checker. At present, subscriptions of \"Is\"","isinstance(obj, str) and NonEmptyStringTest(obj) #* This new class would then be entirely empty.","* Country. # * Currency. #* Comparison constraints # * IdenticalTo. # *","beartype import beartype # from beartype.is import Portable # NonEmptyStringTest = Is[lambda text:","probably *ONLY* using beartype. Right? That said, this would #technically improve portability by","the above example, this would be: # class NonEmptyStringMetaclass(object): # def __isinstancecheck__(cls, obj)","example, this # would be: # class NonEmptyStringClass(object, metaclass=NonEmptyStringMetaclass): # pass # #Well,","#checkers... except not really, since they'd still have to import beartype #infrastructure to","alternate private # names (e.g., \"from argparse import ArgumentParser as _ArgumentParser\" rather #","This new metaclass of this new class simply defines an __isinstancecheck__() # dunder","python3 # --------------------( LICENSE )-------------------- # Copyright (c) 2014-2021 Beartype authors. # See","not really, since they'd still have to import beartype #infrastructure to do so.","idea here is that we can #leverage all of our existing \"beartype.is\" infrastructure","are *not* explicitly covered by existing PEPs and thus *not* directly usable as","PEP-compliant hierarchy of subscriptable (indexable) classes enabling callers to validate the internal structure","objects defined by the :mod:`typing` module (e.g., :attr:`typing.Union`), these classes dynamically generate PEP-compliant","classes. Is = _IsFactory(basename='Is') IsAttr = _IsAttrFactory(basename='IsAttr') IsEqual = _IsEqualFactory(basename='IsEqual') IsInstance = _IsInstanceFactory(basename='IsInstance')","fast -- which is why this won't #be the default approach. For safety,","scope *ONLY* under alternate private # names (e.g., \"from argparse import ArgumentParser as","can #leverage all of our existing \"beartype.is\" infrastructure to dynamically #synthesize PEP-compliant type","... # #So what's the difference between \"typing.Annotated\" and \"beartype.is.Portable\" #then? Simple. The","be: # class NonEmptyStringClass(object, metaclass=NonEmptyStringMetaclass): # pass # #Well, so much for brilliant.","classes dynamically generate PEP-compliant type hints when subscripted (indexed) and are thus intended","#infrastructure to do so. So, this is probably actually useless. # #Nonetheless, the","by existing PEPs and thus *not* directly usable as annotations. Instead, callers are","support constraints resembling: # #* String constraints: # * Email. # * Uuid.","method of each \"_BeartypeValidatorFactoryABC\" subclass will need # to additionally define and pass",") from beartype.vale._is._valeisobj import _IsAttrFactory from beartype.vale._is._valeisoper import _IsEqualFactory # ....................{ SINGLETONS }....................","by allowing users to switch between different #checkers... except not really, since they'd","= Is[lambda text: bool(text)] # NonEmptyString = Portable[str, NonEmptyStringTest] # @beartype # def","# * NotIdenticalTo. # * LessThan. # * GreaterThan. # * Range. #","space and time consumption fast -- which is why this won't #be the","Portable[str, NonEmptyStringTest] # @beartype # def munge_it(text: NonEmptyString) -> str: ... # #So","# * DivisibleBy. #FIXME: Add a new BeartypeValidator.get_cause_or_none() method with the same #signature","CauseSleuth.get_cause_or_none() #method. This new BeartypeValidator.get_cause_or_none() method should then be #called by the \"_peperrorannotated\"","gets #expensive in both space and time consumption fast -- which is why","the idea itself is trivial. We declare a new #\"beartype.is.Portable\" singleton accessed in","external attributes # should be locally imported at module scope *ONLY* under alternate","# return isinstance(obj, str) and NonEmptyStringTest(obj) #* This new class would then be","* Language. # * Locale. # * Country. # * Currency. #* Comparison","do so. So, this is probably actually useless. # #Nonetheless, the idea itself","in both space and time consumption fast -- which is why this won't","Copyright (c) 2014-2021 Beartype authors. # See \"LICENSE\" for further details. ''' **Beartype","submodule. ''' # ....................{ IMPORTS }.................... #!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! # WARNING: To avoid polluting the","so much for brilliant. It's slow and big, so it seems doubtful anyone","scalars, data structures, and third-party objects. Like annotation objects defined by the :mod:`typing`","defined by the :mod:`typing` module, these classes are *not* explicitly covered by existing",")-------------------- # Copyright (c) 2014-2021 Beartype authors. # See \"LICENSE\" for further details.","WARNING: To avoid polluting the public module namespace, external attributes # should be","# from beartype.is import Portable # NonEmptyStringTest = Is[lambda text: bool(text)] # NonEmptyString","one new PEP 3119-compliant #metaclass and associated class whenever subscripted. Clearly, this gets","Delete all private factory classes imported above for safety. del ( _IsFactory, _IsAttrFactory,","* Choice. # * Language. # * Locale. # * Country. # *","safety, this new class does *NOT* subclass the #first subscripted class. Instead: #*","Beartype authors. # See \"LICENSE\" for further details. ''' **Beartype validators.** This submodule","# class NonEmptyStringMetaclass(object): # def __isinstancecheck__(cls, obj) -> bool: # return isinstance(obj, str)","For safety, this new class does *NOT* subclass the #first subscripted class. Instead:","method should then localize to \"self.get_cause_or_none\". #* Each __class_getitem__() dunder method of each","classes support constraints resembling: # #* String constraints: # * Email. # *","# #* String constraints: # * Email. # * Uuid. # * Choice.","NonEmptyStringMetaclass(object): # def __isinstancecheck__(cls, obj) -> bool: # return isinstance(obj, str) and NonEmptyStringTest(obj)","subscripted (indexed) and are thus intended to annotate callables and variables. Unlike annotation","so it seems doubtful anyone #would actually do that. Nonetheless, that's food for","be locally imported at module scope *ONLY* under alternate private # names (e.g.,","accessed in the same way: e.g., # from beartype import beartype # from","NotIdenticalTo. # * LessThan. # * GreaterThan. # * Range. # * DivisibleBy.","which is why this won't #be the default approach. For safety, this new","than merely \"from argparse import ArgumentParser\"). #!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! from beartype.vale._is._valeis import _IsFactory from beartype.vale._is._valeistype","default approach. For safety, this new class does *NOT* subclass the #first subscripted","# @beartype # def munge_it(text: NonEmptyString) -> str: ... # #So what's the","method. For the above example, this would be: # class NonEmptyStringMetaclass(object): # def","# #So what's the difference between \"typing.Annotated\" and \"beartype.is.Portable\" #then? Simple. The latter","messages. Note that this implies that: #* The BeartypeValidator.__init__() method will need to","actually useless. # #Nonetheless, the idea itself is trivial. We declare a new","time consumption fast -- which is why this won't #be the default approach.","# * Uuid. # * Choice. # * Language. # * Locale. #","those hints with (in order): #. The type of those parameters and returns.","IsEqual = _IsEqualFactory(basename='IsEqual') IsInstance = _IsInstanceFactory(basename='IsInstance') IsSubclass = _IsSubclassFactory(basename='IsSubclass') # Delete all private","-> bool: # return isinstance(obj, str) and NonEmptyStringTest(obj) #* This new class would","is that we can #leverage all of our existing \"beartype.is\" infrastructure to dynamically","you're using a runtime type #checker, you're probably *ONLY* using beartype. Right? That","beartype.vale._is._valeistype import ( _IsInstanceFactory, _IsSubclassFactory, ) from beartype.vale._is._valeisobj import _IsAttrFactory from beartype.vale._is._valeisoper import","usable as annotations. Instead, callers are expected to (in order): #. Annotate callable","method should then be #called by the \"_peperrorannotated\" submodule to generate human-readable #exception","these classes dynamically generate PEP-compliant type hints when subscripted (indexed) and are thus","to import beartype #infrastructure to do so. So, this is probably actually useless.","# that method should then localize to \"self.get_cause_or_none\". #* Each __class_getitem__() dunder method","= _IsEqualFactory(basename='IsEqual') IsInstance = _IsInstanceFactory(basename='IsInstance') IsSubclass = _IsSubclassFactory(basename='IsSubclass') # Delete all private factory","subscriptions of classes declared by this submodule. ''' # ....................{ IMPORTS }.................... #!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!","be entirely empty. For the above example, this # would be: # class","= _IsAttrFactory(basename='IsAttr') IsEqual = _IsEqualFactory(basename='IsEqual') IsInstance = _IsInstanceFactory(basename='IsInstance') IsSubclass = _IsSubclassFactory(basename='IsSubclass') # Delete","this # would be: # class NonEmptyStringClass(object, metaclass=NonEmptyStringMetaclass): # pass # #Well, so","classes declared by this submodule. ''' # ....................{ IMPORTS }.................... #!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! # WARNING:","of subscriptable (indexable) classes enabling callers to validate the internal structure of arbitrarily","str: ... # #So what's the difference between \"typing.Annotated\" and \"beartype.is.Portable\" #then? Simple.","''' **Beartype validators.** This submodule publishes a PEP-compliant hierarchy of subscriptable (indexable) classes","merely \"from argparse import ArgumentParser\"). #!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! from beartype.vale._is._valeis import _IsFactory from beartype.vale._is._valeistype import","submodule publishes a PEP-compliant hierarchy of subscriptable (indexable) classes enabling callers to validate","constraints resembling: # #* String constraints: # * Email. # * Uuid. #","should then be #called by the \"_peperrorannotated\" submodule to generate human-readable #exception messages.","polluting the public module namespace, external attributes # should be locally imported at","for safety. del ( _IsFactory, _IsAttrFactory, _IsEqualFactory, _IsInstanceFactory, _IsSubclassFactory, ) # ....................{ TODO","\"LICENSE\" for further details. ''' **Beartype validators.** This submodule publishes a PEP-compliant hierarchy","singletons instantiating these private factory classes. Is = _IsFactory(basename='Is') IsAttr = _IsAttrFactory(basename='IsAttr') IsEqual","mandatory \"get_cause_or_none: Callable[[], Optional[str]]\" parameter, which # that method should then localize to","factory classes imported above for safety. del ( _IsFactory, _IsAttrFactory, _IsEqualFactory, _IsInstanceFactory, _IsSubclassFactory,","to (in order): #. Annotate callable parameters and returns to be validated with","we can #leverage all of our existing \"beartype.is\" infrastructure to dynamically #synthesize PEP-compliant","supported by beartype #itself. Of course, does anyone care? I mean, if you're","\"from argparse import ArgumentParser as _ArgumentParser\" rather # than merely \"from argparse import","example, this would be: # class NonEmptyStringMetaclass(object): # def __isinstancecheck__(cls, obj) -> bool:","#any runtime type checker. At present, subscriptions of \"Is\" (e.g., #\"Annotated[str, Is[lambda text:","(e.g., \"from argparse import ArgumentParser as _ArgumentParser\" rather # than merely \"from argparse","(indexed) and are thus intended to annotate callables and variables. Unlike annotation objects","new class simply defines an __isinstancecheck__() # dunder method. For the above example,","* Email. # * Uuid. # * Choice. # * Language. # *","would then be entirely empty. For the above example, this # would be:","all private factory classes imported above for safety. del ( _IsFactory, _IsAttrFactory, _IsEqualFactory,","this gets #expensive in both space and time consumption fast -- which is","is trivial. We declare a new #\"beartype.is.Portable\" singleton accessed in the same way:","import beartype #infrastructure to do so. So, this is probably actually useless. #","module (e.g., :attr:`typing.Union`), these classes dynamically generate PEP-compliant type hints when subscripted (indexed)","@Saphyel at #32, add support for #additional classes support constraints resembling: # #*","that we can #leverage all of our existing \"beartype.is\" infrastructure to dynamically #synthesize","between different #checkers... except not really, since they'd still have to import beartype","additionally accept a new # mandatory \"get_cause_or_none: Callable[[], Optional[str]]\" parameter, which # that","localize to \"self.get_cause_or_none\". #* Each __class_getitem__() dunder method of each \"_BeartypeValidatorFactoryABC\" subclass will","the default approach. For safety, this new class does *NOT* subclass the #first","_IsAttrFactory from beartype.vale._is._valeisoper import _IsEqualFactory # ....................{ SINGLETONS }.................... # Public factory singletons","#method. This new BeartypeValidator.get_cause_or_none() method should then be #called by the \"_peperrorannotated\" submodule","String constraints: # * Email. # * Uuid. # * Choice. # *","generate human-readable #exception messages. Note that this implies that: #* The BeartypeValidator.__init__() method","here is that we can #leverage all of our existing \"beartype.is\" infrastructure to","callable when creating and returning # its \"BeartypeValidator\" instance. #FIXME: *BRILLIANT IDEA.* Holyshitballstime.","when subscripted (indexed) and are thus intended to annotate callables and variables. Unlike","# names (e.g., \"from argparse import ArgumentParser as _ArgumentParser\" rather # than merely","# #Well, so much for brilliant. It's slow and big, so it seems","BeartypeValidator.__init__() method will need to additionally accept a new # mandatory \"get_cause_or_none: Callable[[],","hints. #. Subscript those hints with (in order): #. The type of those","and third-party objects. Like annotation objects defined by the :mod:`typing` module (e.g., :attr:`typing.Union`),","thus *not* directly usable as annotations. Instead, callers are expected to (in order):","instance. #FIXME: *BRILLIANT IDEA.* Holyshitballstime. The idea here is that we can #leverage","seems doubtful anyone #would actually do that. Nonetheless, that's food for thought for","private factory classes. Is = _IsFactory(basename='Is') IsAttr = _IsAttrFactory(basename='IsAttr') IsEqual = _IsEqualFactory(basename='IsEqual') IsInstance","mean, if you're using a runtime type #checker, you're probably *ONLY* using beartype.","new BeartypeValidator.get_cause_or_none() method should then be #called by the \"_peperrorannotated\" submodule to generate","this submodule. ''' # ....................{ IMPORTS }.................... #!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! # WARNING: To avoid polluting","be: # class NonEmptyStringMetaclass(object): # def __isinstancecheck__(cls, obj) -> bool: # return isinstance(obj,","thus intended to annotate callables and variables. Unlike annotation objects defined by the","#. The type of those parameters and returns. #. One or more subscriptions","annotate callables and variables. Unlike annotation objects defined by the :mod:`typing` module, these","be validated with :pep:`593`-compliant :attr:`typing.Annotated` type hints. #. Subscript those hints with (in","#* This new class would then be entirely empty. For the above example,","present, subscriptions of \"Is\" (e.g., #\"Annotated[str, Is[lambda text: bool(text)]]\") are only supported by","# ....................{ IMPORTS }.................... #!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! # WARNING: To avoid polluting the public module","from beartype.vale._is._valeistype import ( _IsInstanceFactory, _IsSubclassFactory, ) from beartype.vale._is._valeisobj import _IsAttrFactory from beartype.vale._is._valeisoper","course, does anyone care? I mean, if you're using a runtime type #checker,","callable parameters and returns to be validated with :pep:`593`-compliant :attr:`typing.Annotated` type hints. #.","# WARNING: To avoid polluting the public module namespace, external attributes # should","returns. #. One or more subscriptions of classes declared by this submodule. '''","obj) -> bool: # return isinstance(obj, str) and NonEmptyStringTest(obj) #* This new class",":attr:`typing.Annotated` type hints. #. Subscript those hints with (in order): #. The type","Note that this implies that: #* The BeartypeValidator.__init__() method will need to additionally","from beartype import beartype # from beartype.is import Portable # NonEmptyStringTest = Is[lambda","of each \"_BeartypeValidatorFactoryABC\" subclass will need # to additionally define and pass that","# * GreaterThan. # * Range. # * DivisibleBy. #FIXME: Add a new","big, so it seems doubtful anyone #would actually do that. Nonetheless, that's food","of this new class simply defines an __isinstancecheck__() # dunder method. For the","for brilliant. It's slow and big, so it seems doubtful anyone #would actually","more subscriptions of classes declared by this submodule. ''' # ....................{ IMPORTS }....................","# * Range. # * DivisibleBy. #FIXME: Add a new BeartypeValidator.get_cause_or_none() method with","So, this is probably actually useless. # #Nonetheless, the idea itself is trivial.","a new # mandatory \"get_cause_or_none: Callable[[], Optional[str]]\" parameter, which # that method should","See \"LICENSE\" for further details. ''' **Beartype validators.** This submodule publishes a PEP-compliant","for #additional classes support constraints resembling: # #* String constraints: # * Email.","Uuid. # * Choice. # * Language. # * Locale. # * Country.","improve portability by allowing users to switch between different #checkers... except not really,","annotation objects defined by the :mod:`typing` module, these classes are *not* explicitly covered","-- which is why this won't #be the default approach. For safety, this","these classes are *not* explicitly covered by existing PEPs and thus *not* directly","to additionally accept a new # mandatory \"get_cause_or_none: Callable[[], Optional[str]]\" parameter, which #","classes are *not* explicitly covered by existing PEPs and thus *not* directly usable","It's slow and big, so it seems doubtful anyone #would actually do that.","same #signature and docstring as the existing CauseSleuth.get_cause_or_none() #method. This new BeartypeValidator.get_cause_or_none() method","#be the default approach. For safety, this new class does *NOT* subclass the","_IsSubclassFactory, ) # ....................{ TODO }.................... #FIXME: As intelligently requested by @Saphyel at","import Portable # NonEmptyStringTest = Is[lambda text: bool(text)] # NonEmptyString = Portable[str, NonEmptyStringTest]","Callable[[], Optional[str]]\" parameter, which # that method should then localize to \"self.get_cause_or_none\". #*","brilliant. It's slow and big, so it seems doubtful anyone #would actually do","this would #technically improve portability by allowing users to switch between different #checkers...","BeartypeValidator.get_cause_or_none() method should then be #called by the \"_peperrorannotated\" submodule to generate human-readable","generates one new PEP 3119-compliant #metaclass and associated class whenever subscripted. Clearly, this","method with the same #signature and docstring as the existing CauseSleuth.get_cause_or_none() #method. This","(e.g., :attr:`typing.Union`), these classes dynamically generate PEP-compliant type hints when subscripted (indexed) and","munge_it(text: NonEmptyString) -> str: ... # #So what's the difference between \"typing.Annotated\" and","is why this won't #be the default approach. For safety, this new class","\"self.get_cause_or_none\". #* Each __class_getitem__() dunder method of each \"_BeartypeValidatorFactoryABC\" subclass will need #","The BeartypeValidator.__init__() method will need to additionally accept a new # mandatory \"get_cause_or_none:","subclass the #first subscripted class. Instead: #* This new metaclass of this new","*ONLY* under alternate private # names (e.g., \"from argparse import ArgumentParser as _ArgumentParser\"","_ArgumentParser\" rather # than merely \"from argparse import ArgumentParser\"). #!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! from beartype.vale._is._valeis import","the :mod:`typing` module, these classes are *not* explicitly covered by existing PEPs and","-> str: ... # #So what's the difference between \"typing.Annotated\" and \"beartype.is.Portable\" #then?","different #checkers... except not really, since they'd still have to import beartype #infrastructure","a new #\"beartype.is.Portable\" singleton accessed in the same way: e.g., # from beartype","Unlike annotation objects defined by the :mod:`typing` module, these classes are *not* explicitly","}.................... # Public factory singletons instantiating these private factory classes. Is = _IsFactory(basename='Is')","bool(text)] # NonEmptyString = Portable[str, NonEmptyStringTest] # @beartype # def munge_it(text: NonEmptyString) ->","NonEmptyStringTest] # @beartype # def munge_it(text: NonEmptyString) -> str: ... # #So what's","the above example, this # would be: # class NonEmptyStringClass(object, metaclass=NonEmptyStringMetaclass): # pass","then be implicitly supported by #any runtime type checker. At present, subscriptions of","probably actually useless. # #Nonetheless, the idea itself is trivial. We declare a","PEP 3119-compliant #metaclass and associated class whenever subscripted. Clearly, this gets #expensive in","\"beartype.is.Portable\" #then? Simple. The latter dynamically generates one new PEP 3119-compliant #metaclass and","difference between \"typing.Annotated\" and \"beartype.is.Portable\" #then? Simple. The latter dynamically generates one new","Right? That said, this would #technically improve portability by allowing users to switch","#then? Simple. The latter dynamically generates one new PEP 3119-compliant #metaclass and associated","# would be: # class NonEmptyStringClass(object, metaclass=NonEmptyStringMetaclass): # pass # #Well, so much","hints when subscripted (indexed) and are thus intended to annotate callables and variables.","generate PEP-compliant type hints when subscripted (indexed) and are thus intended to annotate","# ....................{ TODO }.................... #FIXME: As intelligently requested by @Saphyel at #32, add","to generate human-readable #exception messages. Note that this implies that: #* The BeartypeValidator.__init__()","#synthesize PEP-compliant type hints that would then be implicitly supported by #any runtime","pass that callable when creating and returning # its \"BeartypeValidator\" instance. #FIXME: *BRILLIANT","beartype.vale._is._valeis import _IsFactory from beartype.vale._is._valeistype import ( _IsInstanceFactory, _IsSubclassFactory, ) from beartype.vale._is._valeisobj import","* Uuid. # * Choice. # * Language. # * Locale. # *","\"_BeartypeValidatorFactoryABC\" subclass will need # to additionally define and pass that callable when","ArgumentParser\"). #!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! from beartype.vale._is._valeis import _IsFactory from beartype.vale._is._valeistype import ( _IsInstanceFactory, _IsSubclassFactory, )","module, these classes are *not* explicitly covered by existing PEPs and thus *not*","_IsEqualFactory # ....................{ SINGLETONS }.................... # Public factory singletons instantiating these private factory","text: bool(text)] # NonEmptyString = Portable[str, NonEmptyStringTest] # @beartype # def munge_it(text: NonEmptyString)","import _IsEqualFactory # ....................{ SINGLETONS }.................... # Public factory singletons instantiating these private","private # names (e.g., \"from argparse import ArgumentParser as _ArgumentParser\" rather # than","annotation objects defined by the :mod:`typing` module (e.g., :attr:`typing.Union`), these classes dynamically generate","import ( _IsInstanceFactory, _IsSubclassFactory, ) from beartype.vale._is._valeisobj import _IsAttrFactory from beartype.vale._is._valeisoper import _IsEqualFactory","PEP-compliant type hints that would then be implicitly supported by #any runtime type","text: bool(text)]]\") are only supported by beartype #itself. Of course, does anyone care?","*ONLY* using beartype. Right? That said, this would #technically improve portability by allowing","metaclass=NonEmptyStringMetaclass): # pass # #Well, so much for brilliant. It's slow and big,","\"beartype.is\" infrastructure to dynamically #synthesize PEP-compliant type hints that would then be implicitly","returns to be validated with :pep:`593`-compliant :attr:`typing.Annotated` type hints. #. Subscript those hints","resembling: # #* String constraints: # * Email. # * Uuid. # *",":mod:`typing` module (e.g., :attr:`typing.Union`), these classes dynamically generate PEP-compliant type hints when subscripted","are thus intended to annotate callables and variables. Unlike annotation objects defined by","#* Comparison constraints # * IdenticalTo. # * NotIdenticalTo. # * LessThan. #","does *NOT* subclass the #first subscripted class. Instead: #* This new metaclass of","#leverage all of our existing \"beartype.is\" infrastructure to dynamically #synthesize PEP-compliant type hints","class NonEmptyStringClass(object, metaclass=NonEmptyStringMetaclass): # pass # #Well, so much for brilliant. It's slow","that callable when creating and returning # its \"BeartypeValidator\" instance. #FIXME: *BRILLIANT IDEA.*","IDEA.* Holyshitballstime. The idea here is that we can #leverage all of our","portability by allowing users to switch between different #checkers... except not really, since","# than merely \"from argparse import ArgumentParser\"). #!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! from beartype.vale._is._valeis import _IsFactory from","objects. Like annotation objects defined by the :mod:`typing` module (e.g., :attr:`typing.Union`), these classes","new BeartypeValidator.get_cause_or_none() method with the same #signature and docstring as the existing CauseSleuth.get_cause_or_none()","creating and returning # its \"BeartypeValidator\" instance. #FIXME: *BRILLIANT IDEA.* Holyshitballstime. The idea","_IsSubclassFactory, ) from beartype.vale._is._valeisobj import _IsAttrFactory from beartype.vale._is._valeisoper import _IsEqualFactory # ....................{ SINGLETONS","enabling callers to validate the internal structure of arbitrarily complex scalars, data structures,","existing PEPs and thus *not* directly usable as annotations. Instead, callers are expected","_IsInstanceFactory, _IsSubclassFactory, ) from beartype.vale._is._valeisobj import _IsAttrFactory from beartype.vale._is._valeisoper import _IsEqualFactory # ....................{","class. Instead: #* This new metaclass of this new class simply defines an","# #Nonetheless, the idea itself is trivial. We declare a new #\"beartype.is.Portable\" singleton","further details. ''' **Beartype validators.** This submodule publishes a PEP-compliant hierarchy of subscriptable","docstring as the existing CauseSleuth.get_cause_or_none() #method. This new BeartypeValidator.get_cause_or_none() method should then be","#!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! # WARNING: To avoid polluting the public module namespace, external attributes #","both space and time consumption fast -- which is why this won't #be","( _IsInstanceFactory, _IsSubclassFactory, ) from beartype.vale._is._valeisobj import _IsAttrFactory from beartype.vale._is._valeisoper import _IsEqualFactory #","define and pass that callable when creating and returning # its \"BeartypeValidator\" instance.","# mandatory \"get_cause_or_none: Callable[[], Optional[str]]\" parameter, which # that method should then localize","type hints when subscripted (indexed) and are thus intended to annotate callables and","this new class does *NOT* subclass the #first subscripted class. Instead: #* This","hints that would then be implicitly supported by #any runtime type checker. At","* NotIdenticalTo. # * LessThan. # * GreaterThan. # * Range. # *","by @Saphyel at #32, add support for #additional classes support constraints resembling: #","a runtime type #checker, you're probably *ONLY* using beartype. Right? That said, this","from beartype.vale._is._valeis import _IsFactory from beartype.vale._is._valeistype import ( _IsInstanceFactory, _IsSubclassFactory, ) from beartype.vale._is._valeisobj","each \"_BeartypeValidatorFactoryABC\" subclass will need # to additionally define and pass that callable","str) and NonEmptyStringTest(obj) #* This new class would then be entirely empty. For","import ArgumentParser\"). #!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! from beartype.vale._is._valeis import _IsFactory from beartype.vale._is._valeistype import ( _IsInstanceFactory, _IsSubclassFactory,","when creating and returning # its \"BeartypeValidator\" instance. #FIXME: *BRILLIANT IDEA.* Holyshitballstime. The","# from beartype import beartype # from beartype.is import Portable # NonEmptyStringTest =","runtime type checker. At present, subscriptions of \"Is\" (e.g., #\"Annotated[str, Is[lambda text: bool(text)]]\")","#FIXME: *BRILLIANT IDEA.* Holyshitballstime. The idea here is that we can #leverage all","of classes declared by this submodule. ''' # ....................{ IMPORTS }.................... #!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! #","to do so. So, this is probably actually useless. # #Nonetheless, the idea","classes imported above for safety. del ( _IsFactory, _IsAttrFactory, _IsEqualFactory, _IsInstanceFactory, _IsSubclassFactory, )","#Well, so much for brilliant. It's slow and big, so it seems doubtful","will need to additionally accept a new # mandatory \"get_cause_or_none: Callable[[], Optional[str]]\" parameter,","a PEP-compliant hierarchy of subscriptable (indexable) classes enabling callers to validate the internal","type hints. #. Subscript those hints with (in order): #. The type of","# * Choice. # * Language. # * Locale. # * Country. #","complex scalars, data structures, and third-party objects. Like annotation objects defined by the","Locale. # * Country. # * Currency. #* Comparison constraints # * IdenticalTo.","submodule to generate human-readable #exception messages. Note that this implies that: #* The","#technically improve portability by allowing users to switch between different #checkers... except not","singleton accessed in the same way: e.g., # from beartype import beartype #","Country. # * Currency. #* Comparison constraints # * IdenticalTo. # * NotIdenticalTo.","supported by #any runtime type checker. At present, subscriptions of \"Is\" (e.g., #\"Annotated[str,","using beartype. Right? That said, this would #technically improve portability by allowing users","subscripted class. Instead: #* This new metaclass of this new class simply defines","so. So, this is probably actually useless. # #Nonetheless, the idea itself is","the difference between \"typing.Annotated\" and \"beartype.is.Portable\" #then? Simple. The latter dynamically generates one","public module namespace, external attributes # should be locally imported at module scope","an __isinstancecheck__() # dunder method. For the above example, this would be: #","runtime type #checker, you're probably *ONLY* using beartype. Right? That said, this would","beartype # from beartype.is import Portable # NonEmptyStringTest = Is[lambda text: bool(text)] #","type of those parameters and returns. #. One or more subscriptions of classes","#signature and docstring as the existing CauseSleuth.get_cause_or_none() #method. This new BeartypeValidator.get_cause_or_none() method should","to additionally define and pass that callable when creating and returning # its","beartype #infrastructure to do so. So, this is probably actually useless. # #Nonetheless,","as _ArgumentParser\" rather # than merely \"from argparse import ArgumentParser\"). #!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! from beartype.vale._is._valeis","= _IsInstanceFactory(basename='IsInstance') IsSubclass = _IsSubclassFactory(basename='IsSubclass') # Delete all private factory classes imported above","I mean, if you're using a runtime type #checker, you're probably *ONLY* using","explicitly covered by existing PEPs and thus *not* directly usable as annotations. Instead,","to switch between different #checkers... except not really, since they'd still have to","This new class would then be entirely empty. For the above example, this","type checker. At present, subscriptions of \"Is\" (e.g., #\"Annotated[str, Is[lambda text: bool(text)]]\") are","#* This new metaclass of this new class simply defines an __isinstancecheck__() #","\"typing.Annotated\" and \"beartype.is.Portable\" #then? Simple. The latter dynamically generates one new PEP 3119-compliant","TODO }.................... #FIXME: As intelligently requested by @Saphyel at #32, add support for","At present, subscriptions of \"Is\" (e.g., #\"Annotated[str, Is[lambda text: bool(text)]]\") are only supported","existing CauseSleuth.get_cause_or_none() #method. This new BeartypeValidator.get_cause_or_none() method should then be #called by the","2014-2021 Beartype authors. # See \"LICENSE\" for further details. ''' **Beartype validators.** This","parameter, which # that method should then localize to \"self.get_cause_or_none\". #* Each __class_getitem__()","type hints that would then be implicitly supported by #any runtime type checker.","and variables. Unlike annotation objects defined by the :mod:`typing` module, these classes are","then be entirely empty. For the above example, this # would be: #","Subscript those hints with (in order): #. The type of those parameters and","#FIXME: As intelligently requested by @Saphyel at #32, add support for #additional classes","the :mod:`typing` module (e.g., :attr:`typing.Union`), these classes dynamically generate PEP-compliant type hints when","should be locally imported at module scope *ONLY* under alternate private # names","import _IsAttrFactory from beartype.vale._is._valeisoper import _IsEqualFactory # ....................{ SINGLETONS }.................... # Public factory","imported above for safety. del ( _IsFactory, _IsAttrFactory, _IsEqualFactory, _IsInstanceFactory, _IsSubclassFactory, ) #","GreaterThan. # * Range. # * DivisibleBy. #FIXME: Add a new BeartypeValidator.get_cause_or_none() method","existing \"beartype.is\" infrastructure to dynamically #synthesize PEP-compliant type hints that would then be","authors. # See \"LICENSE\" for further details. ''' **Beartype validators.** This submodule publishes","the same way: e.g., # from beartype import beartype # from beartype.is import","# def munge_it(text: NonEmptyString) -> str: ... # #So what's the difference between","to annotate callables and variables. Unlike annotation objects defined by the :mod:`typing` module,","whenever subscripted. Clearly, this gets #expensive in both space and time consumption fast","Like annotation objects defined by the :mod:`typing` module (e.g., :attr:`typing.Union`), these classes dynamically","_IsFactory, _IsAttrFactory, _IsEqualFactory, _IsInstanceFactory, _IsSubclassFactory, ) # ....................{ TODO }.................... #FIXME: As intelligently","order): #. The type of those parameters and returns. #. One or more","by beartype #itself. Of course, does anyone care? I mean, if you're using","approach. For safety, this new class does *NOT* subclass the #first subscripted class.","hierarchy of subscriptable (indexable) classes enabling callers to validate the internal structure of","NonEmptyStringTest(obj) #* This new class would then be entirely empty. For the above","ArgumentParser as _ArgumentParser\" rather # than merely \"from argparse import ArgumentParser\"). #!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! from","parameters and returns to be validated with :pep:`593`-compliant :attr:`typing.Annotated` type hints. #. Subscript","private factory classes imported above for safety. del ( _IsFactory, _IsAttrFactory, _IsEqualFactory, _IsInstanceFactory,","which # that method should then localize to \"self.get_cause_or_none\". #* Each __class_getitem__() dunder","bool: # return isinstance(obj, str) and NonEmptyStringTest(obj) #* This new class would then","Currency. #* Comparison constraints # * IdenticalTo. # * NotIdenticalTo. # * LessThan.","# dunder method. For the above example, this would be: # class NonEmptyStringMetaclass(object):","Is = _IsFactory(basename='Is') IsAttr = _IsAttrFactory(basename='IsAttr') IsEqual = _IsEqualFactory(basename='IsEqual') IsInstance = _IsInstanceFactory(basename='IsInstance') IsSubclass","and docstring as the existing CauseSleuth.get_cause_or_none() #method. This new BeartypeValidator.get_cause_or_none() method should then","# Delete all private factory classes imported above for safety. del ( _IsFactory,","* LessThan. # * GreaterThan. # * Range. # * DivisibleBy. #FIXME: Add","LICENSE )-------------------- # Copyright (c) 2014-2021 Beartype authors. # See \"LICENSE\" for further","from beartype.vale._is._valeisobj import _IsAttrFactory from beartype.vale._is._valeisoper import _IsEqualFactory # ....................{ SINGLETONS }.................... #","new PEP 3119-compliant #metaclass and associated class whenever subscripted. Clearly, this gets #expensive","third-party objects. Like annotation objects defined by the :mod:`typing` module (e.g., :attr:`typing.Union`), these","same way: e.g., # from beartype import beartype # from beartype.is import Portable","#itself. Of course, does anyone care? I mean, if you're using a runtime","#* The BeartypeValidator.__init__() method will need to additionally accept a new # mandatory","order): #. Annotate callable parameters and returns to be validated with :pep:`593`-compliant :attr:`typing.Annotated`","with :pep:`593`-compliant :attr:`typing.Annotated` type hints. #. Subscript those hints with (in order): #.","as annotations. Instead, callers are expected to (in order): #. Annotate callable parameters","_IsEqualFactory(basename='IsEqual') IsInstance = _IsInstanceFactory(basename='IsInstance') IsSubclass = _IsSubclassFactory(basename='IsSubclass') # Delete all private factory classes","and \"beartype.is.Portable\" #then? Simple. The latter dynamically generates one new PEP 3119-compliant #metaclass","objects defined by the :mod:`typing` module, these classes are *not* explicitly covered by","and returning # its \"BeartypeValidator\" instance. #FIXME: *BRILLIANT IDEA.* Holyshitballstime. The idea here","support for #additional classes support constraints resembling: # #* String constraints: # *","def munge_it(text: NonEmptyString) -> str: ... # #So what's the difference between \"typing.Annotated\"","publishes a PEP-compliant hierarchy of subscriptable (indexable) classes enabling callers to validate the","at #32, add support for #additional classes support constraints resembling: # #* String","the internal structure of arbitrarily complex scalars, data structures, and third-party objects. Like","way: e.g., # from beartype import beartype # from beartype.is import Portable #","as the existing CauseSleuth.get_cause_or_none() #method. This new BeartypeValidator.get_cause_or_none() method should then be #called","beartype.vale._is._valeisobj import _IsAttrFactory from beartype.vale._is._valeisoper import _IsEqualFactory # ....................{ SINGLETONS }.................... # Public","\"Is\" (e.g., #\"Annotated[str, Is[lambda text: bool(text)]]\") are only supported by beartype #itself. Of","defines an __isinstancecheck__() # dunder method. For the above example, this would be:","hints with (in order): #. The type of those parameters and returns. #.","entirely empty. For the above example, this # would be: # class NonEmptyStringClass(object,","#first subscripted class. Instead: #* This new metaclass of this new class simply","by #any runtime type checker. At present, subscriptions of \"Is\" (e.g., #\"Annotated[str, Is[lambda","....................{ IMPORTS }.................... #!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! # WARNING: To avoid polluting the public module namespace,","variables. Unlike annotation objects defined by the :mod:`typing` module, these classes are *not*","= _IsFactory(basename='Is') IsAttr = _IsAttrFactory(basename='IsAttr') IsEqual = _IsEqualFactory(basename='IsEqual') IsInstance = _IsInstanceFactory(basename='IsInstance') IsSubclass =","the #first subscripted class. Instead: #* This new metaclass of this new class","#Nonetheless, the idea itself is trivial. We declare a new #\"beartype.is.Portable\" singleton accessed","(in order): #. The type of those parameters and returns. #. One or","idea itself is trivial. We declare a new #\"beartype.is.Portable\" singleton accessed in the","requested by @Saphyel at #32, add support for #additional classes support constraints resembling:","This new BeartypeValidator.get_cause_or_none() method should then be #called by the \"_peperrorannotated\" submodule to","really, since they'd still have to import beartype #infrastructure to do so. So,","....................{ SINGLETONS }.................... # Public factory singletons instantiating these private factory classes. Is","_IsFactory from beartype.vale._is._valeistype import ( _IsInstanceFactory, _IsSubclassFactory, ) from beartype.vale._is._valeisobj import _IsAttrFactory from","Clearly, this gets #expensive in both space and time consumption fast -- which","Instead: #* This new metaclass of this new class simply defines an __isinstancecheck__()","type #checker, you're probably *ONLY* using beartype. Right? That said, this would #technically","would then be implicitly supported by #any runtime type checker. At present, subscriptions","*not* explicitly covered by existing PEPs and thus *not* directly usable as annotations.","* IdenticalTo. # * NotIdenticalTo. # * LessThan. # * GreaterThan. # *","at module scope *ONLY* under alternate private # names (e.g., \"from argparse import","(in order): #. Annotate callable parameters and returns to be validated with :pep:`593`-compliant","implies that: #* The BeartypeValidator.__init__() method will need to additionally accept a new","allowing users to switch between different #checkers... except not really, since they'd still","Comparison constraints # * IdenticalTo. # * NotIdenticalTo. # * LessThan. # *","would be: # class NonEmptyStringClass(object, metaclass=NonEmptyStringMetaclass): # pass # #Well, so much for","by the \"_peperrorannotated\" submodule to generate human-readable #exception messages. Note that this implies","\"_peperrorannotated\" submodule to generate human-readable #exception messages. Note that this implies that: #*","Range. # * DivisibleBy. #FIXME: Add a new BeartypeValidator.get_cause_or_none() method with the same","metaclass of this new class simply defines an __isinstancecheck__() # dunder method. For","and returns. #. One or more subscriptions of classes declared by this submodule.","for further details. ''' **Beartype validators.** This submodule publishes a PEP-compliant hierarchy of","# See \"LICENSE\" for further details. ''' **Beartype validators.** This submodule publishes a","with (in order): #. The type of those parameters and returns. #. One","**Beartype validators.** This submodule publishes a PEP-compliant hierarchy of subscriptable (indexable) classes enabling","only supported by beartype #itself. Of course, does anyone care? I mean, if","avoid polluting the public module namespace, external attributes # should be locally imported","would be: # class NonEmptyStringMetaclass(object): # def __isinstancecheck__(cls, obj) -> bool: # return","internal structure of arbitrarily complex scalars, data structures, and third-party objects. Like annotation","from beartype.vale._is._valeisoper import _IsEqualFactory # ....................{ SINGLETONS }.................... # Public factory singletons instantiating","IsInstance = _IsInstanceFactory(basename='IsInstance') IsSubclass = _IsSubclassFactory(basename='IsSubclass') # Delete all private factory classes imported","# Copyright (c) 2014-2021 Beartype authors. # See \"LICENSE\" for further details. '''","That said, this would #technically improve portability by allowing users to switch between","new # mandatory \"get_cause_or_none: Callable[[], Optional[str]]\" parameter, which # that method should then","this new class simply defines an __isinstancecheck__() # dunder method. For the above","are only supported by beartype #itself. Of course, does anyone care? I mean,","does anyone care? I mean, if you're using a runtime type #checker, you're","that this implies that: #* The BeartypeValidator.__init__() method will need to additionally accept","*BRILLIANT IDEA.* Holyshitballstime. The idea here is that we can #leverage all of","(c) 2014-2021 Beartype authors. # See \"LICENSE\" for further details. ''' **Beartype validators.**","to dynamically #synthesize PEP-compliant type hints that would then be implicitly supported by","PEPs and thus *not* directly usable as annotations. Instead, callers are expected to","IdenticalTo. # * NotIdenticalTo. # * LessThan. # * GreaterThan. # * Range.","won't #be the default approach. For safety, this new class does *NOT* subclass","validated with :pep:`593`-compliant :attr:`typing.Annotated` type hints. #. Subscript those hints with (in order):","__isinstancecheck__(cls, obj) -> bool: # return isinstance(obj, str) and NonEmptyStringTest(obj) #* This new","safety. del ( _IsFactory, _IsAttrFactory, _IsEqualFactory, _IsInstanceFactory, _IsSubclassFactory, ) # ....................{ TODO }....................","IsAttr = _IsAttrFactory(basename='IsAttr') IsEqual = _IsEqualFactory(basename='IsEqual') IsInstance = _IsInstanceFactory(basename='IsInstance') IsSubclass = _IsSubclassFactory(basename='IsSubclass') #","* Currency. #* Comparison constraints # * IdenticalTo. # * NotIdenticalTo. # *","new class does *NOT* subclass the #first subscripted class. Instead: #* This new","For the above example, this would be: # class NonEmptyStringMetaclass(object): # def __isinstancecheck__(cls,","and returns to be validated with :pep:`593`-compliant :attr:`typing.Annotated` type hints. #. Subscript those","Add a new BeartypeValidator.get_cause_or_none() method with the same #signature and docstring as the","method will need to additionally accept a new # mandatory \"get_cause_or_none: Callable[[], Optional[str]]\"","the same #signature and docstring as the existing CauseSleuth.get_cause_or_none() #method. This new BeartypeValidator.get_cause_or_none()","except not really, since they'd still have to import beartype #infrastructure to do","LessThan. # * GreaterThan. # * Range. # * DivisibleBy. #FIXME: Add a","declared by this submodule. ''' # ....................{ IMPORTS }.................... #!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! # WARNING: To","switch between different #checkers... except not really, since they'd still have to import","return isinstance(obj, str) and NonEmptyStringTest(obj) #* This new class would then be entirely","parameters and returns. #. One or more subscriptions of classes declared by this","and thus *not* directly usable as annotations. Instead, callers are expected to (in","of arbitrarily complex scalars, data structures, and third-party objects. Like annotation objects defined","beartype.vale._is._valeisoper import _IsEqualFactory # ....................{ SINGLETONS }.................... # Public factory singletons instantiating these","with the same #signature and docstring as the existing CauseSleuth.get_cause_or_none() #method. This new","The latter dynamically generates one new PEP 3119-compliant #metaclass and associated class whenever","# pass # #Well, so much for brilliant. It's slow and big, so"],"string":"[\n \"IMPORTS }.................... #!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! # WARNING: To avoid polluting the public module namespace, external\",\n \"this is probably actually useless. # #Nonetheless, the idea itself is trivial. We\",\n \"#* Each __class_getitem__() dunder method of each \\\"_BeartypeValidatorFactoryABC\\\" subclass will need # to\",\n \"instantiating these private factory classes. Is = _IsFactory(basename='Is') IsAttr = _IsAttrFactory(basename='IsAttr') IsEqual =\",\n \"or more subscriptions of classes declared by this submodule. ''' # ....................{ IMPORTS\",\n \"constraints # * IdenticalTo. # * NotIdenticalTo. # * LessThan. # * GreaterThan.\",\n \"NonEmptyString) -> str: ... # #So what's the difference between \\\"typing.Annotated\\\" and \\\"beartype.is.Portable\\\"\",\n \"argparse import ArgumentParser as _ArgumentParser\\\" rather # than merely \\\"from argparse import ArgumentParser\\\").\",\n \"NonEmptyString = Portable[str, NonEmptyStringTest] # @beartype # def munge_it(text: NonEmptyString) -> str: ...\",\n \"# def __isinstancecheck__(cls, obj) -> bool: # return isinstance(obj, str) and NonEmptyStringTest(obj) #*\",\n \"new #\\\"beartype.is.Portable\\\" singleton accessed in the same way: e.g., # from beartype import\",\n \"subscriptable (indexable) classes enabling callers to validate the internal structure of arbitrarily complex\",\n \"above for safety. del ( _IsFactory, _IsAttrFactory, _IsEqualFactory, _IsInstanceFactory, _IsSubclassFactory, ) # ....................{\",\n \"it seems doubtful anyone #would actually do that. Nonetheless, that's food for thought\",\n \"this implies that: #* The BeartypeValidator.__init__() method will need to additionally accept a\",\n \"}.................... #FIXME: As intelligently requested by @Saphyel at #32, add support for #additional\",\n \"what's the difference between \\\"typing.Annotated\\\" and \\\"beartype.is.Portable\\\" #then? Simple. The latter dynamically generates\",\n \"accept a new # mandatory \\\"get_cause_or_none: Callable[[], Optional[str]]\\\" parameter, which # that method\",\n \"the existing CauseSleuth.get_cause_or_none() #method. This new BeartypeValidator.get_cause_or_none() method should then be #called by\",\n \"We declare a new #\\\"beartype.is.Portable\\\" singleton accessed in the same way: e.g., #\",\n \"Simple. The latter dynamically generates one new PEP 3119-compliant #metaclass and associated class\",\n \"#FIXME: Add a new BeartypeValidator.get_cause_or_none() method with the same #signature and docstring as\",\n \"NonEmptyStringClass(object, metaclass=NonEmptyStringMetaclass): # pass # #Well, so much for brilliant. It's slow and\",\n \"then localize to \\\"self.get_cause_or_none\\\". #* Each __class_getitem__() dunder method of each \\\"_BeartypeValidatorFactoryABC\\\" subclass\",\n \"( _IsFactory, _IsAttrFactory, _IsEqualFactory, _IsInstanceFactory, _IsSubclassFactory, ) # ....................{ TODO }.................... #FIXME: As\",\n \"to validate the internal structure of arbitrarily complex scalars, data structures, and third-party\",\n \":attr:`typing.Union`), these classes dynamically generate PEP-compliant type hints when subscripted (indexed) and are\",\n \"that: #* The BeartypeValidator.__init__() method will need to additionally accept a new #\",\n \"using a runtime type #checker, you're probably *ONLY* using beartype. Right? That said,\",\n \"* GreaterThan. # * Range. # * DivisibleBy. #FIXME: Add a new BeartypeValidator.get_cause_or_none()\",\n \"Is[lambda text: bool(text)] # NonEmptyString = Portable[str, NonEmptyStringTest] # @beartype # def munge_it(text:\",\n \"(indexable) classes enabling callers to validate the internal structure of arbitrarily complex scalars,\",\n \"__isinstancecheck__() # dunder method. For the above example, this would be: # class\",\n \"beartype.is import Portable # NonEmptyStringTest = Is[lambda text: bool(text)] # NonEmptyString = Portable[str,\",\n \"slow and big, so it seems doubtful anyone #would actually do that. Nonetheless,\",\n \"This submodule publishes a PEP-compliant hierarchy of subscriptable (indexable) classes enabling callers to\",\n \"#* String constraints: # * Email. # * Uuid. # * Choice. #\",\n \"module scope *ONLY* under alternate private # names (e.g., \\\"from argparse import ArgumentParser\",\n \"callables and variables. Unlike annotation objects defined by the :mod:`typing` module, these classes\",\n \"expected to (in order): #. Annotate callable parameters and returns to be validated\",\n \"rather # than merely \\\"from argparse import ArgumentParser\\\"). #!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! from beartype.vale._is._valeis import _IsFactory\",\n \"bool(text)]]\\\") are only supported by beartype #itself. Of course, does anyone care? I\",\n \"*not* directly usable as annotations. Instead, callers are expected to (in order): #.\",\n \"* Locale. # * Country. # * Currency. #* Comparison constraints # *\",\n \"Choice. # * Language. # * Locale. # * Country. # * Currency.\",\n \"import ArgumentParser as _ArgumentParser\\\" rather # than merely \\\"from argparse import ArgumentParser\\\"). #!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\",\n \"subscripted. Clearly, this gets #expensive in both space and time consumption fast --\",\n \"need to additionally accept a new # mandatory \\\"get_cause_or_none: Callable[[], Optional[str]]\\\" parameter, which\",\n \"}.................... #!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! # WARNING: To avoid polluting the public module namespace, external attributes\",\n \":mod:`typing` module, these classes are *not* explicitly covered by existing PEPs and thus\",\n \"of \\\"Is\\\" (e.g., #\\\"Annotated[str, Is[lambda text: bool(text)]]\\\") are only supported by beartype #itself.\",\n \"# * Currency. #* Comparison constraints # * IdenticalTo. # * NotIdenticalTo. #\",\n \"#additional classes support constraints resembling: # #* String constraints: # * Email. #\",\n \"subscriptions of \\\"Is\\\" (e.g., #\\\"Annotated[str, Is[lambda text: bool(text)]]\\\") are only supported by beartype\",\n \"since they'd still have to import beartype #infrastructure to do so. So, this\",\n \"in the same way: e.g., # from beartype import beartype # from beartype.is\",\n \"new class would then be entirely empty. For the above example, this #\",\n \"\\\"BeartypeValidator\\\" instance. #FIXME: *BRILLIANT IDEA.* Holyshitballstime. The idea here is that we can\",\n \"consumption fast -- which is why this won't #be the default approach. For\",\n \"* Range. # * DivisibleBy. #FIXME: Add a new BeartypeValidator.get_cause_or_none() method with the\",\n \"and pass that callable when creating and returning # its \\\"BeartypeValidator\\\" instance. #FIXME:\",\n \"its \\\"BeartypeValidator\\\" instance. #FIXME: *BRILLIANT IDEA.* Holyshitballstime. The idea here is that we\",\n \"#expensive in both space and time consumption fast -- which is why this\",\n \"subclass will need # to additionally define and pass that callable when creating\",\n \"# NonEmptyString = Portable[str, NonEmptyStringTest] # @beartype # def munge_it(text: NonEmptyString) -> str:\",\n \"_IsEqualFactory, _IsInstanceFactory, _IsSubclassFactory, ) # ....................{ TODO }.................... #FIXME: As intelligently requested by\",\n \"Instead, callers are expected to (in order): #. Annotate callable parameters and returns\",\n \"and associated class whenever subscripted. Clearly, this gets #expensive in both space and\",\n \"dynamically #synthesize PEP-compliant type hints that would then be implicitly supported by #any\",\n \"# * LessThan. # * GreaterThan. # * Range. # * DivisibleBy. #FIXME:\",\n \"that would then be implicitly supported by #any runtime type checker. At present,\",\n \"(e.g., #\\\"Annotated[str, Is[lambda text: bool(text)]]\\\") are only supported by beartype #itself. Of course,\",\n \"is probably actually useless. # #Nonetheless, the idea itself is trivial. We declare\",\n \"# class NonEmptyStringClass(object, metaclass=NonEmptyStringMetaclass): # pass # #Well, so much for brilliant. It's\",\n \"The type of those parameters and returns. #. One or more subscriptions of\",\n \"@beartype # def munge_it(text: NonEmptyString) -> str: ... # #So what's the difference\",\n \"#. Subscript those hints with (in order): #. The type of those parameters\",\n \"annotations. Instead, callers are expected to (in order): #. Annotate callable parameters and\",\n \"e.g., # from beartype import beartype # from beartype.is import Portable # NonEmptyStringTest\",\n \"declare a new #\\\"beartype.is.Portable\\\" singleton accessed in the same way: e.g., # from\",\n \"callers are expected to (in order): #. Annotate callable parameters and returns to\",\n \"from beartype.is import Portable # NonEmptyStringTest = Is[lambda text: bool(text)] # NonEmptyString =\",\n \"this won't #be the default approach. For safety, this new class does *NOT*\",\n \"Holyshitballstime. The idea here is that we can #leverage all of our existing\",\n \"dynamically generates one new PEP 3119-compliant #metaclass and associated class whenever subscripted. Clearly,\",\n \"# * Language. # * Locale. # * Country. # * Currency. #*\",\n \"structure of arbitrarily complex scalars, data structures, and third-party objects. Like annotation objects\",\n \"del ( _IsFactory, _IsAttrFactory, _IsEqualFactory, _IsInstanceFactory, _IsSubclassFactory, ) # ....................{ TODO }.................... #FIXME:\",\n \"human-readable #exception messages. Note that this implies that: #* The BeartypeValidator.__init__() method will\",\n \"need # to additionally define and pass that callable when creating and returning\",\n \"you're probably *ONLY* using beartype. Right? That said, this would #technically improve portability\",\n \"data structures, and third-party objects. Like annotation objects defined by the :mod:`typing` module\",\n \"be #called by the \\\"_peperrorannotated\\\" submodule to generate human-readable #exception messages. Note that\",\n \"# * Locale. # * Country. # * Currency. #* Comparison constraints #\",\n \"\\\"get_cause_or_none: Callable[[], Optional[str]]\\\" parameter, which # that method should then localize to \\\"self.get_cause_or_none\\\".\",\n \"much for brilliant. It's slow and big, so it seems doubtful anyone #would\",\n \"dunder method. For the above example, this would be: # class NonEmptyStringMetaclass(object): #\",\n \"Portable # NonEmptyStringTest = Is[lambda text: bool(text)] # NonEmptyString = Portable[str, NonEmptyStringTest] #\",\n \"are expected to (in order): #. Annotate callable parameters and returns to be\",\n \"class does *NOT* subclass the #first subscripted class. Instead: #* This new metaclass\",\n \"dunder method of each \\\"_BeartypeValidatorFactoryABC\\\" subclass will need # to additionally define and\",\n \"if you're using a runtime type #checker, you're probably *ONLY* using beartype. Right?\",\n \"checker. At present, subscriptions of \\\"Is\\\" (e.g., #\\\"Annotated[str, Is[lambda text: bool(text)]]\\\") are only\",\n \"infrastructure to dynamically #synthesize PEP-compliant type hints that would then be implicitly supported\",\n \"the \\\"_peperrorannotated\\\" submodule to generate human-readable #exception messages. Note that this implies that:\",\n \"simply defines an __isinstancecheck__() # dunder method. For the above example, this would\",\n \"One or more subscriptions of classes declared by this submodule. ''' # ....................{\",\n \"Optional[str]]\\\" parameter, which # that method should then localize to \\\"self.get_cause_or_none\\\". #* Each\",\n \"care? I mean, if you're using a runtime type #checker, you're probably *ONLY*\",\n \"The idea here is that we can #leverage all of our existing \\\"beartype.is\\\"\",\n \"names (e.g., \\\"from argparse import ArgumentParser as _ArgumentParser\\\" rather # than merely \\\"from\",\n \"factory singletons instantiating these private factory classes. Is = _IsFactory(basename='Is') IsAttr = _IsAttrFactory(basename='IsAttr')\",\n \"#. One or more subscriptions of classes declared by this submodule. ''' #\",\n \"latter dynamically generates one new PEP 3119-compliant #metaclass and associated class whenever subscripted.\",\n \"_IsInstanceFactory(basename='IsInstance') IsSubclass = _IsSubclassFactory(basename='IsSubclass') # Delete all private factory classes imported above for\",\n \"attributes # should be locally imported at module scope *ONLY* under alternate private\",\n \"#So what's the difference between \\\"typing.Annotated\\\" and \\\"beartype.is.Portable\\\" #then? Simple. The latter dynamically\",\n \":pep:`593`-compliant :attr:`typing.Annotated` type hints. #. Subscript those hints with (in order): #. The\",\n \"import _IsFactory from beartype.vale._is._valeistype import ( _IsInstanceFactory, _IsSubclassFactory, ) from beartype.vale._is._valeisobj import _IsAttrFactory\",\n \"doubtful anyone #would actually do that. Nonetheless, that's food for thought for you.\",\n \"# should be locally imported at module scope *ONLY* under alternate private #\",\n \"class whenever subscripted. Clearly, this gets #expensive in both space and time consumption\",\n \"_IsSubclassFactory(basename='IsSubclass') # Delete all private factory classes imported above for safety. del (\",\n \"constraints: # * Email. # * Uuid. # * Choice. # * Language.\",\n \"PEP-compliant type hints when subscripted (indexed) and are thus intended to annotate callables\",\n \"defined by the :mod:`typing` module (e.g., :attr:`typing.Union`), these classes dynamically generate PEP-compliant type\",\n \"anyone care? I mean, if you're using a runtime type #checker, you're probably\",\n \"#exception messages. Note that this implies that: #* The BeartypeValidator.__init__() method will need\",\n \"As intelligently requested by @Saphyel at #32, add support for #additional classes support\",\n \"callers to validate the internal structure of arbitrarily complex scalars, data structures, and\",\n \"arbitrarily complex scalars, data structures, and third-party objects. Like annotation objects defined by\",\n \"# --------------------( LICENSE )-------------------- # Copyright (c) 2014-2021 Beartype authors. # See \\\"LICENSE\\\"\",\n \"Is[lambda text: bool(text)]]\\\") are only supported by beartype #itself. Of course, does anyone\",\n \"add support for #additional classes support constraints resembling: # #* String constraints: #\",\n \"# * Country. # * Currency. #* Comparison constraints # * IdenticalTo. #\",\n \"argparse import ArgumentParser\\\"). #!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! from beartype.vale._is._valeis import _IsFactory from beartype.vale._is._valeistype import ( _IsInstanceFactory,\",\n \"why this won't #be the default approach. For safety, this new class does\",\n \"For the above example, this # would be: # class NonEmptyStringClass(object, metaclass=NonEmptyStringMetaclass): #\",\n \"\\\"from argparse import ArgumentParser\\\"). #!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! from beartype.vale._is._valeis import _IsFactory from beartype.vale._is._valeistype import (\",\n \"def __isinstancecheck__(cls, obj) -> bool: # return isinstance(obj, str) and NonEmptyStringTest(obj) #* This\",\n \"''' # ....................{ IMPORTS }.................... #!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! # WARNING: To avoid polluting the public\",\n \"intended to annotate callables and variables. Unlike annotation objects defined by the :mod:`typing`\",\n \"# * Email. # * Uuid. # * Choice. # * Language. #\",\n \"of those parameters and returns. #. One or more subscriptions of classes declared\",\n \"....................{ TODO }.................... #FIXME: As intelligently requested by @Saphyel at #32, add support\",\n \"# to additionally define and pass that callable when creating and returning #\",\n \"# * IdenticalTo. # * NotIdenticalTo. # * LessThan. # * GreaterThan. #\",\n \"beartype. Right? That said, this would #technically improve portability by allowing users to\",\n \"users to switch between different #checkers... except not really, since they'd still have\",\n \"above example, this # would be: # class NonEmptyStringClass(object, metaclass=NonEmptyStringMetaclass): # pass #\",\n \"--------------------( LICENSE )-------------------- # Copyright (c) 2014-2021 Beartype authors. # See \\\"LICENSE\\\" for\",\n \"#called by the \\\"_peperrorannotated\\\" submodule to generate human-readable #exception messages. Note that this\",\n \"by this submodule. ''' # ....................{ IMPORTS }.................... #!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! # WARNING: To avoid\",\n \"would #technically improve portability by allowing users to switch between different #checkers... except\",\n \"validate the internal structure of arbitrarily complex scalars, data structures, and third-party objects.\",\n \"useless. # #Nonetheless, the idea itself is trivial. We declare a new #\\\"beartype.is.Portable\\\"\",\n \"above example, this would be: # class NonEmptyStringMetaclass(object): # def __isinstancecheck__(cls, obj) ->\",\n \"beartype #itself. Of course, does anyone care? I mean, if you're using a\",\n \"structures, and third-party objects. Like annotation objects defined by the :mod:`typing` module (e.g.,\",\n \"these private factory classes. Is = _IsFactory(basename='Is') IsAttr = _IsAttrFactory(basename='IsAttr') IsEqual = _IsEqualFactory(basename='IsEqual')\",\n \"locally imported at module scope *ONLY* under alternate private # names (e.g., \\\"from\",\n \"validators.** This submodule publishes a PEP-compliant hierarchy of subscriptable (indexable) classes enabling callers\",\n \"DivisibleBy. #FIXME: Add a new BeartypeValidator.get_cause_or_none() method with the same #signature and docstring\",\n \"Each __class_getitem__() dunder method of each \\\"_BeartypeValidatorFactoryABC\\\" subclass will need # to additionally\",\n \"our existing \\\"beartype.is\\\" infrastructure to dynamically #synthesize PEP-compliant type hints that would then\",\n \"class NonEmptyStringMetaclass(object): # def __isinstancecheck__(cls, obj) -> bool: # return isinstance(obj, str) and\",\n \"and time consumption fast -- which is why this won't #be the default\",\n \"new metaclass of this new class simply defines an __isinstancecheck__() # dunder method.\",\n \"itself is trivial. We declare a new #\\\"beartype.is.Portable\\\" singleton accessed in the same\",\n \"between \\\"typing.Annotated\\\" and \\\"beartype.is.Portable\\\" #then? Simple. The latter dynamically generates one new PEP\",\n \"and big, so it seems doubtful anyone #would actually do that. Nonetheless, that's\",\n \"_IsInstanceFactory, _IsSubclassFactory, ) # ....................{ TODO }.................... #FIXME: As intelligently requested by @Saphyel\",\n \"#checker, you're probably *ONLY* using beartype. Right? That said, this would #technically improve\",\n \"= _IsSubclassFactory(basename='IsSubclass') # Delete all private factory classes imported above for safety. del\",\n \"the public module namespace, external attributes # should be locally imported at module\",\n \"class simply defines an __isinstancecheck__() # dunder method. For the above example, this\",\n \"by the :mod:`typing` module (e.g., :attr:`typing.Union`), these classes dynamically generate PEP-compliant type hints\",\n \"#!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! from beartype.vale._is._valeis import _IsFactory from beartype.vale._is._valeistype import ( _IsInstanceFactory, _IsSubclassFactory, ) from\",\n \"they'd still have to import beartype #infrastructure to do so. So, this is\",\n \"will need # to additionally define and pass that callable when creating and\",\n \"Of course, does anyone care? I mean, if you're using a runtime type\",\n \"# ....................{ SINGLETONS }.................... # Public factory singletons instantiating these private factory classes.\",\n \"a new BeartypeValidator.get_cause_or_none() method with the same #signature and docstring as the existing\",\n \"_IsAttrFactory, _IsEqualFactory, _IsInstanceFactory, _IsSubclassFactory, ) # ....................{ TODO }.................... #FIXME: As intelligently requested\",\n \"dynamically generate PEP-compliant type hints when subscripted (indexed) and are thus intended to\",\n \"to \\\"self.get_cause_or_none\\\". #* Each __class_getitem__() dunder method of each \\\"_BeartypeValidatorFactoryABC\\\" subclass will need\",\n \"#\\\"beartype.is.Portable\\\" singleton accessed in the same way: e.g., # from beartype import beartype\",\n \"details. ''' **Beartype validators.** This submodule publishes a PEP-compliant hierarchy of subscriptable (indexable)\",\n \"empty. For the above example, this # would be: # class NonEmptyStringClass(object, metaclass=NonEmptyStringMetaclass):\",\n \"module namespace, external attributes # should be locally imported at module scope *ONLY*\",\n \"still have to import beartype #infrastructure to do so. So, this is probably\",\n \"trivial. We declare a new #\\\"beartype.is.Portable\\\" singleton accessed in the same way: e.g.,\",\n \"imported at module scope *ONLY* under alternate private # names (e.g., \\\"from argparse\",\n \"by the :mod:`typing` module, these classes are *not* explicitly covered by existing PEPs\",\n \"and are thus intended to annotate callables and variables. Unlike annotation objects defined\",\n \"= Portable[str, NonEmptyStringTest] # @beartype # def munge_it(text: NonEmptyString) -> str: ... #\",\n \"associated class whenever subscripted. Clearly, this gets #expensive in both space and time\",\n \"__class_getitem__() dunder method of each \\\"_BeartypeValidatorFactoryABC\\\" subclass will need # to additionally define\",\n \"have to import beartype #infrastructure to do so. So, this is probably actually\",\n \"directly usable as annotations. Instead, callers are expected to (in order): #. Annotate\",\n \"intelligently requested by @Saphyel at #32, add support for #additional classes support constraints\",\n \"#metaclass and associated class whenever subscripted. Clearly, this gets #expensive in both space\",\n \") # ....................{ TODO }.................... #FIXME: As intelligently requested by @Saphyel at #32,\",\n \"_IsFactory(basename='Is') IsAttr = _IsAttrFactory(basename='IsAttr') IsEqual = _IsEqualFactory(basename='IsEqual') IsInstance = _IsInstanceFactory(basename='IsInstance') IsSubclass = _IsSubclassFactory(basename='IsSubclass')\",\n \"said, this would #technically improve portability by allowing users to switch between different\",\n \"namespace, external attributes # should be locally imported at module scope *ONLY* under\",\n \"BeartypeValidator.get_cause_or_none() method with the same #signature and docstring as the existing CauseSleuth.get_cause_or_none() #method.\",\n \"should then localize to \\\"self.get_cause_or_none\\\". #* Each __class_getitem__() dunder method of each \\\"_BeartypeValidatorFactoryABC\\\"\",\n \"*NOT* subclass the #first subscripted class. Instead: #* This new metaclass of this\",\n \"SINGLETONS }.................... # Public factory singletons instantiating these private factory classes. Is =\",\n \"# Public factory singletons instantiating these private factory classes. Is = _IsFactory(basename='Is') IsAttr\",\n \"Public factory singletons instantiating these private factory classes. Is = _IsFactory(basename='Is') IsAttr =\",\n \"that method should then localize to \\\"self.get_cause_or_none\\\". #* Each __class_getitem__() dunder method of\",\n \"to be validated with :pep:`593`-compliant :attr:`typing.Annotated` type hints. #. Subscript those hints with\",\n \"#32, add support for #additional classes support constraints resembling: # #* String constraints:\",\n \"IsSubclass = _IsSubclassFactory(basename='IsSubclass') # Delete all private factory classes imported above for safety.\",\n \"#\\\"Annotated[str, Is[lambda text: bool(text)]]\\\") are only supported by beartype #itself. Of course, does\",\n \"and NonEmptyStringTest(obj) #* This new class would then be entirely empty. For the\",\n \"3119-compliant #metaclass and associated class whenever subscripted. Clearly, this gets #expensive in both\",\n \"#!/usr/bin/env python3 # --------------------( LICENSE )-------------------- # Copyright (c) 2014-2021 Beartype authors. #\",\n \"implicitly supported by #any runtime type checker. At present, subscriptions of \\\"Is\\\" (e.g.,\",\n \"pass # #Well, so much for brilliant. It's slow and big, so it\",\n \"# its \\\"BeartypeValidator\\\" instance. #FIXME: *BRILLIANT IDEA.* Holyshitballstime. The idea here is that\",\n \"those parameters and returns. #. One or more subscriptions of classes declared by\",\n \"To avoid polluting the public module namespace, external attributes # should be locally\",\n \"Email. # * Uuid. # * Choice. # * Language. # * Locale.\",\n \"then be #called by the \\\"_peperrorannotated\\\" submodule to generate human-readable #exception messages. Note\",\n \"under alternate private # names (e.g., \\\"from argparse import ArgumentParser as _ArgumentParser\\\" rather\",\n \"factory classes. Is = _IsFactory(basename='Is') IsAttr = _IsAttrFactory(basename='IsAttr') IsEqual = _IsEqualFactory(basename='IsEqual') IsInstance =\",\n \"_IsAttrFactory(basename='IsAttr') IsEqual = _IsEqualFactory(basename='IsEqual') IsInstance = _IsInstanceFactory(basename='IsInstance') IsSubclass = _IsSubclassFactory(basename='IsSubclass') # Delete all\",\n \"* DivisibleBy. #FIXME: Add a new BeartypeValidator.get_cause_or_none() method with the same #signature and\",\n \"additionally define and pass that callable when creating and returning # its \\\"BeartypeValidator\\\"\",\n \"classes enabling callers to validate the internal structure of arbitrarily complex scalars, data\",\n \"of our existing \\\"beartype.is\\\" infrastructure to dynamically #synthesize PEP-compliant type hints that would\",\n \"this would be: # class NonEmptyStringMetaclass(object): # def __isinstancecheck__(cls, obj) -> bool: #\",\n \"Annotate callable parameters and returns to be validated with :pep:`593`-compliant :attr:`typing.Annotated` type hints.\",\n \"Language. # * Locale. # * Country. # * Currency. #* Comparison constraints\",\n \"returning # its \\\"BeartypeValidator\\\" instance. #FIXME: *BRILLIANT IDEA.* Holyshitballstime. The idea here is\",\n \"covered by existing PEPs and thus *not* directly usable as annotations. Instead, callers\",\n \"import beartype # from beartype.is import Portable # NonEmptyStringTest = Is[lambda text: bool(text)]\",\n \"NonEmptyStringTest = Is[lambda text: bool(text)] # NonEmptyString = Portable[str, NonEmptyStringTest] # @beartype #\",\n \"# NonEmptyStringTest = Is[lambda text: bool(text)] # NonEmptyString = Portable[str, NonEmptyStringTest] # @beartype\",\n \"all of our existing \\\"beartype.is\\\" infrastructure to dynamically #synthesize PEP-compliant type hints that\",\n \"class would then be entirely empty. For the above example, this # would\",\n \"#. Annotate callable parameters and returns to be validated with :pep:`593`-compliant :attr:`typing.Annotated` type\",\n \"be implicitly supported by #any runtime type checker. At present, subscriptions of \\\"Is\\\"\",\n \"isinstance(obj, str) and NonEmptyStringTest(obj) #* This new class would then be entirely empty.\",\n \"* Country. # * Currency. #* Comparison constraints # * IdenticalTo. # *\",\n \"beartype import beartype # from beartype.is import Portable # NonEmptyStringTest = Is[lambda text:\",\n \"probably *ONLY* using beartype. Right? That said, this would #technically improve portability by\",\n \"the above example, this would be: # class NonEmptyStringMetaclass(object): # def __isinstancecheck__(cls, obj)\",\n \"example, this # would be: # class NonEmptyStringClass(object, metaclass=NonEmptyStringMetaclass): # pass # #Well,\",\n \"#checkers... except not really, since they'd still have to import beartype #infrastructure to\",\n \"alternate private # names (e.g., \\\"from argparse import ArgumentParser as _ArgumentParser\\\" rather #\",\n \"This new metaclass of this new class simply defines an __isinstancecheck__() # dunder\",\n \"python3 # --------------------( LICENSE )-------------------- # Copyright (c) 2014-2021 Beartype authors. # See\",\n \"not really, since they'd still have to import beartype #infrastructure to do so.\",\n \"idea here is that we can #leverage all of our existing \\\"beartype.is\\\" infrastructure\",\n \"are *not* explicitly covered by existing PEPs and thus *not* directly usable as\",\n \"PEP-compliant hierarchy of subscriptable (indexable) classes enabling callers to validate the internal structure\",\n \"objects defined by the :mod:`typing` module (e.g., :attr:`typing.Union`), these classes dynamically generate PEP-compliant\",\n \"classes. Is = _IsFactory(basename='Is') IsAttr = _IsAttrFactory(basename='IsAttr') IsEqual = _IsEqualFactory(basename='IsEqual') IsInstance = _IsInstanceFactory(basename='IsInstance')\",\n \"fast -- which is why this won't #be the default approach. For safety,\",\n \"scope *ONLY* under alternate private # names (e.g., \\\"from argparse import ArgumentParser as\",\n \"can #leverage all of our existing \\\"beartype.is\\\" infrastructure to dynamically #synthesize PEP-compliant type\",\n \"... # #So what's the difference between \\\"typing.Annotated\\\" and \\\"beartype.is.Portable\\\" #then? Simple. The\",\n \"be: # class NonEmptyStringClass(object, metaclass=NonEmptyStringMetaclass): # pass # #Well, so much for brilliant.\",\n \"classes dynamically generate PEP-compliant type hints when subscripted (indexed) and are thus intended\",\n \"#infrastructure to do so. So, this is probably actually useless. # #Nonetheless, the\",\n \"by existing PEPs and thus *not* directly usable as annotations. Instead, callers are\",\n \"support constraints resembling: # #* String constraints: # * Email. # * Uuid.\",\n \"method of each \\\"_BeartypeValidatorFactoryABC\\\" subclass will need # to additionally define and pass\",\n \") from beartype.vale._is._valeisobj import _IsAttrFactory from beartype.vale._is._valeisoper import _IsEqualFactory # ....................{ SINGLETONS }....................\",\n \"by allowing users to switch between different #checkers... except not really, since they'd\",\n \"= Is[lambda text: bool(text)] # NonEmptyString = Portable[str, NonEmptyStringTest] # @beartype # def\",\n \"# * NotIdenticalTo. # * LessThan. # * GreaterThan. # * Range. #\",\n \"space and time consumption fast -- which is why this won't #be the\",\n \"Portable[str, NonEmptyStringTest] # @beartype # def munge_it(text: NonEmptyString) -> str: ... # #So\",\n \"# * DivisibleBy. #FIXME: Add a new BeartypeValidator.get_cause_or_none() method with the same #signature\",\n \"CauseSleuth.get_cause_or_none() #method. This new BeartypeValidator.get_cause_or_none() method should then be #called by the \\\"_peperrorannotated\\\"\",\n \"gets #expensive in both space and time consumption fast -- which is why\",\n \"the idea itself is trivial. We declare a new #\\\"beartype.is.Portable\\\" singleton accessed in\",\n \"external attributes # should be locally imported at module scope *ONLY* under alternate\",\n \"# return isinstance(obj, str) and NonEmptyStringTest(obj) #* This new class would then be\",\n \"* Language. # * Locale. # * Country. # * Currency. #* Comparison\",\n \"do so. So, this is probably actually useless. # #Nonetheless, the idea itself\",\n \"in both space and time consumption fast -- which is why this won't\",\n \"Copyright (c) 2014-2021 Beartype authors. # See \\\"LICENSE\\\" for further details. ''' **Beartype\",\n \"submodule. ''' # ....................{ IMPORTS }.................... #!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! # WARNING: To avoid polluting the\",\n \"so much for brilliant. It's slow and big, so it seems doubtful anyone\",\n \"scalars, data structures, and third-party objects. Like annotation objects defined by the :mod:`typing`\",\n \"defined by the :mod:`typing` module, these classes are *not* explicitly covered by existing\",\n \")-------------------- # Copyright (c) 2014-2021 Beartype authors. # See \\\"LICENSE\\\" for further details.\",\n \"WARNING: To avoid polluting the public module namespace, external attributes # should be\",\n \"# from beartype.is import Portable # NonEmptyStringTest = Is[lambda text: bool(text)] # NonEmptyString\",\n \"one new PEP 3119-compliant #metaclass and associated class whenever subscripted. Clearly, this gets\",\n \"Delete all private factory classes imported above for safety. del ( _IsFactory, _IsAttrFactory,\",\n \"* Choice. # * Language. # * Locale. # * Country. # *\",\n \"safety, this new class does *NOT* subclass the #first subscripted class. Instead: #*\",\n \"Beartype authors. # See \\\"LICENSE\\\" for further details. ''' **Beartype validators.** This submodule\",\n \"# class NonEmptyStringMetaclass(object): # def __isinstancecheck__(cls, obj) -> bool: # return isinstance(obj, str)\",\n \"For safety, this new class does *NOT* subclass the #first subscripted class. Instead:\",\n \"method should then localize to \\\"self.get_cause_or_none\\\". #* Each __class_getitem__() dunder method of each\",\n \"classes support constraints resembling: # #* String constraints: # * Email. # *\",\n \"# #* String constraints: # * Email. # * Uuid. # * Choice.\",\n \"NonEmptyStringMetaclass(object): # def __isinstancecheck__(cls, obj) -> bool: # return isinstance(obj, str) and NonEmptyStringTest(obj)\",\n \"subscripted (indexed) and are thus intended to annotate callables and variables. Unlike annotation\",\n \"so it seems doubtful anyone #would actually do that. Nonetheless, that's food for\",\n \"be locally imported at module scope *ONLY* under alternate private # names (e.g.,\",\n \"accessed in the same way: e.g., # from beartype import beartype # from\",\n \"NotIdenticalTo. # * LessThan. # * GreaterThan. # * Range. # * DivisibleBy.\",\n \"which is why this won't #be the default approach. For safety, this new\",\n \"than merely \\\"from argparse import ArgumentParser\\\"). #!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! from beartype.vale._is._valeis import _IsFactory from beartype.vale._is._valeistype\",\n \"default approach. For safety, this new class does *NOT* subclass the #first subscripted\",\n \"# @beartype # def munge_it(text: NonEmptyString) -> str: ... # #So what's the\",\n \"method. For the above example, this would be: # class NonEmptyStringMetaclass(object): # def\",\n \"# #So what's the difference between \\\"typing.Annotated\\\" and \\\"beartype.is.Portable\\\" #then? Simple. The latter\",\n \"messages. Note that this implies that: #* The BeartypeValidator.__init__() method will need to\",\n \"actually useless. # #Nonetheless, the idea itself is trivial. We declare a new\",\n \"time consumption fast -- which is why this won't #be the default approach.\",\n \"# * Uuid. # * Choice. # * Language. # * Locale. #\",\n \"those hints with (in order): #. The type of those parameters and returns.\",\n \"IsEqual = _IsEqualFactory(basename='IsEqual') IsInstance = _IsInstanceFactory(basename='IsInstance') IsSubclass = _IsSubclassFactory(basename='IsSubclass') # Delete all private\",\n \"-> bool: # return isinstance(obj, str) and NonEmptyStringTest(obj) #* This new class would\",\n \"is that we can #leverage all of our existing \\\"beartype.is\\\" infrastructure to dynamically\",\n \"you're using a runtime type #checker, you're probably *ONLY* using beartype. Right? That\",\n \"beartype.vale._is._valeistype import ( _IsInstanceFactory, _IsSubclassFactory, ) from beartype.vale._is._valeisobj import _IsAttrFactory from beartype.vale._is._valeisoper import\",\n \"usable as annotations. Instead, callers are expected to (in order): #. Annotate callable\",\n \"method should then be #called by the \\\"_peperrorannotated\\\" submodule to generate human-readable #exception\",\n \"these classes dynamically generate PEP-compliant type hints when subscripted (indexed) and are thus\",\n \"to import beartype #infrastructure to do so. So, this is probably actually useless.\",\n \"# that method should then localize to \\\"self.get_cause_or_none\\\". #* Each __class_getitem__() dunder method\",\n \"= _IsEqualFactory(basename='IsEqual') IsInstance = _IsInstanceFactory(basename='IsInstance') IsSubclass = _IsSubclassFactory(basename='IsSubclass') # Delete all private factory\",\n \"subscriptions of classes declared by this submodule. ''' # ....................{ IMPORTS }.................... #!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\",\n \"be entirely empty. For the above example, this # would be: # class\",\n \"= _IsAttrFactory(basename='IsAttr') IsEqual = _IsEqualFactory(basename='IsEqual') IsInstance = _IsInstanceFactory(basename='IsInstance') IsSubclass = _IsSubclassFactory(basename='IsSubclass') # Delete\",\n \"this # would be: # class NonEmptyStringClass(object, metaclass=NonEmptyStringMetaclass): # pass # #Well, so\",\n \"classes declared by this submodule. ''' # ....................{ IMPORTS }.................... #!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! # WARNING:\",\n \"of subscriptable (indexable) classes enabling callers to validate the internal structure of arbitrarily\",\n \"str: ... # #So what's the difference between \\\"typing.Annotated\\\" and \\\"beartype.is.Portable\\\" #then? Simple.\",\n \"''' **Beartype validators.** This submodule publishes a PEP-compliant hierarchy of subscriptable (indexable) classes\",\n \"merely \\\"from argparse import ArgumentParser\\\"). #!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! from beartype.vale._is._valeis import _IsFactory from beartype.vale._is._valeistype import\",\n \"submodule publishes a PEP-compliant hierarchy of subscriptable (indexable) classes enabling callers to validate\",\n \"constraints resembling: # #* String constraints: # * Email. # * Uuid. #\",\n \"should then be #called by the \\\"_peperrorannotated\\\" submodule to generate human-readable #exception messages.\",\n \"polluting the public module namespace, external attributes # should be locally imported at\",\n \"for safety. del ( _IsFactory, _IsAttrFactory, _IsEqualFactory, _IsInstanceFactory, _IsSubclassFactory, ) # ....................{ TODO\",\n \"\\\"LICENSE\\\" for further details. ''' **Beartype validators.** This submodule publishes a PEP-compliant hierarchy\",\n \"singletons instantiating these private factory classes. Is = _IsFactory(basename='Is') IsAttr = _IsAttrFactory(basename='IsAttr') IsEqual\",\n \"mandatory \\\"get_cause_or_none: Callable[[], Optional[str]]\\\" parameter, which # that method should then localize to\",\n \"factory classes imported above for safety. del ( _IsFactory, _IsAttrFactory, _IsEqualFactory, _IsInstanceFactory, _IsSubclassFactory,\",\n \"to (in order): #. Annotate callable parameters and returns to be validated with\",\n \"we can #leverage all of our existing \\\"beartype.is\\\" infrastructure to dynamically #synthesize PEP-compliant\",\n \"supported by beartype #itself. Of course, does anyone care? I mean, if you're\",\n \"\\\"from argparse import ArgumentParser as _ArgumentParser\\\" rather # than merely \\\"from argparse import\",\n \"example, this would be: # class NonEmptyStringMetaclass(object): # def __isinstancecheck__(cls, obj) -> bool:\",\n \"#any runtime type checker. At present, subscriptions of \\\"Is\\\" (e.g., #\\\"Annotated[str, Is[lambda text:\",\n \"(e.g., \\\"from argparse import ArgumentParser as _ArgumentParser\\\" rather # than merely \\\"from argparse\",\n \"(indexed) and are thus intended to annotate callables and variables. Unlike annotation objects\",\n \"new class simply defines an __isinstancecheck__() # dunder method. For the above example,\",\n \"* Email. # * Uuid. # * Choice. # * Language. # *\",\n \"would then be entirely empty. For the above example, this # would be:\",\n \"all private factory classes imported above for safety. del ( _IsFactory, _IsAttrFactory, _IsEqualFactory,\",\n \"this gets #expensive in both space and time consumption fast -- which is\",\n \"is trivial. We declare a new #\\\"beartype.is.Portable\\\" singleton accessed in the same way:\",\n \"import beartype #infrastructure to do so. So, this is probably actually useless. #\",\n \"module (e.g., :attr:`typing.Union`), these classes dynamically generate PEP-compliant type hints when subscripted (indexed)\",\n \"@Saphyel at #32, add support for #additional classes support constraints resembling: # #*\",\n \"that we can #leverage all of our existing \\\"beartype.is\\\" infrastructure to dynamically #synthesize\",\n \"between different #checkers... except not really, since they'd still have to import beartype\",\n \"additionally accept a new # mandatory \\\"get_cause_or_none: Callable[[], Optional[str]]\\\" parameter, which # that\",\n \"localize to \\\"self.get_cause_or_none\\\". #* Each __class_getitem__() dunder method of each \\\"_BeartypeValidatorFactoryABC\\\" subclass will\",\n \"the default approach. For safety, this new class does *NOT* subclass the #first\",\n \"_IsAttrFactory from beartype.vale._is._valeisoper import _IsEqualFactory # ....................{ SINGLETONS }.................... # Public factory singletons\",\n \"#method. This new BeartypeValidator.get_cause_or_none() method should then be #called by the \\\"_peperrorannotated\\\" submodule\",\n \"String constraints: # * Email. # * Uuid. # * Choice. # *\",\n \"generate human-readable #exception messages. Note that this implies that: #* The BeartypeValidator.__init__() method\",\n \"here is that we can #leverage all of our existing \\\"beartype.is\\\" infrastructure to\",\n \"callable when creating and returning # its \\\"BeartypeValidator\\\" instance. #FIXME: *BRILLIANT IDEA.* Holyshitballstime.\",\n \"when subscripted (indexed) and are thus intended to annotate callables and variables. Unlike\",\n \"# names (e.g., \\\"from argparse import ArgumentParser as _ArgumentParser\\\" rather # than merely\",\n \"# #Well, so much for brilliant. It's slow and big, so it seems\",\n \"BeartypeValidator.__init__() method will need to additionally accept a new # mandatory \\\"get_cause_or_none: Callable[[],\",\n \"hints. #. Subscript those hints with (in order): #. The type of those\",\n \"and third-party objects. Like annotation objects defined by the :mod:`typing` module (e.g., :attr:`typing.Union`),\",\n \"thus *not* directly usable as annotations. Instead, callers are expected to (in order):\",\n \"instance. #FIXME: *BRILLIANT IDEA.* Holyshitballstime. The idea here is that we can #leverage\",\n \"seems doubtful anyone #would actually do that. Nonetheless, that's food for thought for\",\n \"private factory classes. Is = _IsFactory(basename='Is') IsAttr = _IsAttrFactory(basename='IsAttr') IsEqual = _IsEqualFactory(basename='IsEqual') IsInstance\",\n \"mean, if you're using a runtime type #checker, you're probably *ONLY* using beartype.\",\n \"new BeartypeValidator.get_cause_or_none() method should then be #called by the \\\"_peperrorannotated\\\" submodule to generate\",\n \"this submodule. ''' # ....................{ IMPORTS }.................... #!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! # WARNING: To avoid polluting\",\n \"be: # class NonEmptyStringMetaclass(object): # def __isinstancecheck__(cls, obj) -> bool: # return isinstance(obj,\",\n \"thus intended to annotate callables and variables. Unlike annotation objects defined by the\",\n \"#. The type of those parameters and returns. #. One or more subscriptions\",\n \"annotate callables and variables. Unlike annotation objects defined by the :mod:`typing` module, these\",\n \"be validated with :pep:`593`-compliant :attr:`typing.Annotated` type hints. #. Subscript those hints with (in\",\n \"#* This new class would then be entirely empty. For the above example,\",\n \"present, subscriptions of \\\"Is\\\" (e.g., #\\\"Annotated[str, Is[lambda text: bool(text)]]\\\") are only supported by\",\n \"# ....................{ IMPORTS }.................... #!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! # WARNING: To avoid polluting the public module\",\n \"from beartype.vale._is._valeistype import ( _IsInstanceFactory, _IsSubclassFactory, ) from beartype.vale._is._valeisobj import _IsAttrFactory from beartype.vale._is._valeisoper\",\n \"course, does anyone care? I mean, if you're using a runtime type #checker,\",\n \"callable parameters and returns to be validated with :pep:`593`-compliant :attr:`typing.Annotated` type hints. #.\",\n \"# WARNING: To avoid polluting the public module namespace, external attributes # should\",\n \"returns. #. One or more subscriptions of classes declared by this submodule. '''\",\n \"obj) -> bool: # return isinstance(obj, str) and NonEmptyStringTest(obj) #* This new class\",\n \":attr:`typing.Annotated` type hints. #. Subscript those hints with (in order): #. The type\",\n \"Note that this implies that: #* The BeartypeValidator.__init__() method will need to additionally\",\n \"from beartype import beartype # from beartype.is import Portable # NonEmptyStringTest = Is[lambda\",\n \"of each \\\"_BeartypeValidatorFactoryABC\\\" subclass will need # to additionally define and pass that\",\n \"# * GreaterThan. # * Range. # * DivisibleBy. #FIXME: Add a new\",\n \"big, so it seems doubtful anyone #would actually do that. Nonetheless, that's food\",\n \"of this new class simply defines an __isinstancecheck__() # dunder method. For the\",\n \"for brilliant. It's slow and big, so it seems doubtful anyone #would actually\",\n \"more subscriptions of classes declared by this submodule. ''' # ....................{ IMPORTS }....................\",\n \"# * Range. # * DivisibleBy. #FIXME: Add a new BeartypeValidator.get_cause_or_none() method with\",\n \"So, this is probably actually useless. # #Nonetheless, the idea itself is trivial.\",\n \"a new # mandatory \\\"get_cause_or_none: Callable[[], Optional[str]]\\\" parameter, which # that method should\",\n \"See \\\"LICENSE\\\" for further details. ''' **Beartype validators.** This submodule publishes a PEP-compliant\",\n \"for #additional classes support constraints resembling: # #* String constraints: # * Email.\",\n \"Uuid. # * Choice. # * Language. # * Locale. # * Country.\",\n \"improve portability by allowing users to switch between different #checkers... except not really,\",\n \"annotation objects defined by the :mod:`typing` module, these classes are *not* explicitly covered\",\n \"-- which is why this won't #be the default approach. For safety, this\",\n \"these classes are *not* explicitly covered by existing PEPs and thus *not* directly\",\n \"to additionally accept a new # mandatory \\\"get_cause_or_none: Callable[[], Optional[str]]\\\" parameter, which #\",\n \"classes are *not* explicitly covered by existing PEPs and thus *not* directly usable\",\n \"It's slow and big, so it seems doubtful anyone #would actually do that.\",\n \"same #signature and docstring as the existing CauseSleuth.get_cause_or_none() #method. This new BeartypeValidator.get_cause_or_none() method\",\n \"#be the default approach. For safety, this new class does *NOT* subclass the\",\n \"_IsSubclassFactory, ) # ....................{ TODO }.................... #FIXME: As intelligently requested by @Saphyel at\",\n \"import Portable # NonEmptyStringTest = Is[lambda text: bool(text)] # NonEmptyString = Portable[str, NonEmptyStringTest]\",\n \"Callable[[], Optional[str]]\\\" parameter, which # that method should then localize to \\\"self.get_cause_or_none\\\". #*\",\n \"brilliant. It's slow and big, so it seems doubtful anyone #would actually do\",\n \"this would #technically improve portability by allowing users to switch between different #checkers...\",\n \"BeartypeValidator.get_cause_or_none() method should then be #called by the \\\"_peperrorannotated\\\" submodule to generate human-readable\",\n \"generates one new PEP 3119-compliant #metaclass and associated class whenever subscripted. Clearly, this\",\n \"method with the same #signature and docstring as the existing CauseSleuth.get_cause_or_none() #method. This\",\n \"(e.g., :attr:`typing.Union`), these classes dynamically generate PEP-compliant type hints when subscripted (indexed) and\",\n \"munge_it(text: NonEmptyString) -> str: ... # #So what's the difference between \\\"typing.Annotated\\\" and\",\n \"is why this won't #be the default approach. For safety, this new class\",\n \"\\\"self.get_cause_or_none\\\". #* Each __class_getitem__() dunder method of each \\\"_BeartypeValidatorFactoryABC\\\" subclass will need #\",\n \"The BeartypeValidator.__init__() method will need to additionally accept a new # mandatory \\\"get_cause_or_none:\",\n \"subclass the #first subscripted class. Instead: #* This new metaclass of this new\",\n \"*ONLY* under alternate private # names (e.g., \\\"from argparse import ArgumentParser as _ArgumentParser\\\"\",\n \"_ArgumentParser\\\" rather # than merely \\\"from argparse import ArgumentParser\\\"). #!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! from beartype.vale._is._valeis import\",\n \"the :mod:`typing` module, these classes are *not* explicitly covered by existing PEPs and\",\n \"-> str: ... # #So what's the difference between \\\"typing.Annotated\\\" and \\\"beartype.is.Portable\\\" #then?\",\n \"different #checkers... except not really, since they'd still have to import beartype #infrastructure\",\n \"a new #\\\"beartype.is.Portable\\\" singleton accessed in the same way: e.g., # from beartype\",\n \"Unlike annotation objects defined by the :mod:`typing` module, these classes are *not* explicitly\",\n \"}.................... # Public factory singletons instantiating these private factory classes. Is = _IsFactory(basename='Is')\",\n \"bool(text)] # NonEmptyString = Portable[str, NonEmptyStringTest] # @beartype # def munge_it(text: NonEmptyString) ->\",\n \"NonEmptyStringTest] # @beartype # def munge_it(text: NonEmptyString) -> str: ... # #So what's\",\n \"the above example, this # would be: # class NonEmptyStringClass(object, metaclass=NonEmptyStringMetaclass): # pass\",\n \"then be implicitly supported by #any runtime type checker. At present, subscriptions of\",\n \"probably actually useless. # #Nonetheless, the idea itself is trivial. We declare a\",\n \"PEP 3119-compliant #metaclass and associated class whenever subscripted. Clearly, this gets #expensive in\",\n \"\\\"beartype.is.Portable\\\" #then? Simple. The latter dynamically generates one new PEP 3119-compliant #metaclass and\",\n \"difference between \\\"typing.Annotated\\\" and \\\"beartype.is.Portable\\\" #then? Simple. The latter dynamically generates one new\",\n \"Right? That said, this would #technically improve portability by allowing users to switch\",\n \"#then? Simple. The latter dynamically generates one new PEP 3119-compliant #metaclass and associated\",\n \"# would be: # class NonEmptyStringClass(object, metaclass=NonEmptyStringMetaclass): # pass # #Well, so much\",\n \"hints when subscripted (indexed) and are thus intended to annotate callables and variables.\",\n \"generate PEP-compliant type hints when subscripted (indexed) and are thus intended to annotate\",\n \"# ....................{ TODO }.................... #FIXME: As intelligently requested by @Saphyel at #32, add\",\n \"to generate human-readable #exception messages. Note that this implies that: #* The BeartypeValidator.__init__()\",\n \"#synthesize PEP-compliant type hints that would then be implicitly supported by #any runtime\",\n \"pass that callable when creating and returning # its \\\"BeartypeValidator\\\" instance. #FIXME: *BRILLIANT\",\n \"beartype.vale._is._valeis import _IsFactory from beartype.vale._is._valeistype import ( _IsInstanceFactory, _IsSubclassFactory, ) from beartype.vale._is._valeisobj import\",\n \"* Uuid. # * Choice. # * Language. # * Locale. # *\",\n \"\\\"_BeartypeValidatorFactoryABC\\\" subclass will need # to additionally define and pass that callable when\",\n \"ArgumentParser\\\"). #!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! from beartype.vale._is._valeis import _IsFactory from beartype.vale._is._valeistype import ( _IsInstanceFactory, _IsSubclassFactory, )\",\n \"module, these classes are *not* explicitly covered by existing PEPs and thus *not*\",\n \"_IsEqualFactory # ....................{ SINGLETONS }.................... # Public factory singletons instantiating these private factory\",\n \"text: bool(text)] # NonEmptyString = Portable[str, NonEmptyStringTest] # @beartype # def munge_it(text: NonEmptyString)\",\n \"import _IsEqualFactory # ....................{ SINGLETONS }.................... # Public factory singletons instantiating these private\",\n \"private # names (e.g., \\\"from argparse import ArgumentParser as _ArgumentParser\\\" rather # than\",\n \"annotation objects defined by the :mod:`typing` module (e.g., :attr:`typing.Union`), these classes dynamically generate\",\n \"import ( _IsInstanceFactory, _IsSubclassFactory, ) from beartype.vale._is._valeisobj import _IsAttrFactory from beartype.vale._is._valeisoper import _IsEqualFactory\",\n \"PEP-compliant type hints that would then be implicitly supported by #any runtime type\",\n \"text: bool(text)]]\\\") are only supported by beartype #itself. Of course, does anyone care?\",\n \"*ONLY* using beartype. Right? That said, this would #technically improve portability by allowing\",\n \"metaclass=NonEmptyStringMetaclass): # pass # #Well, so much for brilliant. It's slow and big,\",\n \"\\\"beartype.is\\\" infrastructure to dynamically #synthesize PEP-compliant type hints that would then be implicitly\",\n \"returns to be validated with :pep:`593`-compliant :attr:`typing.Annotated` type hints. #. Subscript those hints\",\n \"resembling: # #* String constraints: # * Email. # * Uuid. # *\",\n \":mod:`typing` module (e.g., :attr:`typing.Union`), these classes dynamically generate PEP-compliant type hints when subscripted\",\n \"are thus intended to annotate callables and variables. Unlike annotation objects defined by\",\n \"#* Comparison constraints # * IdenticalTo. # * NotIdenticalTo. # * LessThan. #\",\n \"does *NOT* subclass the #first subscripted class. Instead: #* This new metaclass of\",\n \"#leverage all of our existing \\\"beartype.is\\\" infrastructure to dynamically #synthesize PEP-compliant type hints\",\n \"class NonEmptyStringClass(object, metaclass=NonEmptyStringMetaclass): # pass # #Well, so much for brilliant. It's slow\",\n \"that callable when creating and returning # its \\\"BeartypeValidator\\\" instance. #FIXME: *BRILLIANT IDEA.*\",\n \"IDEA.* Holyshitballstime. The idea here is that we can #leverage all of our\",\n \"portability by allowing users to switch between different #checkers... except not really, since\",\n \"# than merely \\\"from argparse import ArgumentParser\\\"). #!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! from beartype.vale._is._valeis import _IsFactory from\",\n \"objects. Like annotation objects defined by the :mod:`typing` module (e.g., :attr:`typing.Union`), these classes\",\n \"new BeartypeValidator.get_cause_or_none() method with the same #signature and docstring as the existing CauseSleuth.get_cause_or_none()\",\n \"creating and returning # its \\\"BeartypeValidator\\\" instance. #FIXME: *BRILLIANT IDEA.* Holyshitballstime. The idea\",\n \"_IsSubclassFactory, ) from beartype.vale._is._valeisobj import _IsAttrFactory from beartype.vale._is._valeisoper import _IsEqualFactory # ....................{ SINGLETONS\",\n \"enabling callers to validate the internal structure of arbitrarily complex scalars, data structures,\",\n \"existing PEPs and thus *not* directly usable as annotations. Instead, callers are expected\",\n \"_IsInstanceFactory, _IsSubclassFactory, ) from beartype.vale._is._valeisobj import _IsAttrFactory from beartype.vale._is._valeisoper import _IsEqualFactory # ....................{\",\n \"class. Instead: #* This new metaclass of this new class simply defines an\",\n \"# #Nonetheless, the idea itself is trivial. We declare a new #\\\"beartype.is.Portable\\\" singleton\",\n \"further details. ''' **Beartype validators.** This submodule publishes a PEP-compliant hierarchy of subscriptable\",\n \"docstring as the existing CauseSleuth.get_cause_or_none() #method. This new BeartypeValidator.get_cause_or_none() method should then be\",\n \"#!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! # WARNING: To avoid polluting the public module namespace, external attributes #\",\n \"both space and time consumption fast -- which is why this won't #be\",\n \"( _IsInstanceFactory, _IsSubclassFactory, ) from beartype.vale._is._valeisobj import _IsAttrFactory from beartype.vale._is._valeisoper import _IsEqualFactory #\",\n \"define and pass that callable when creating and returning # its \\\"BeartypeValidator\\\" instance.\",\n \"# mandatory \\\"get_cause_or_none: Callable[[], Optional[str]]\\\" parameter, which # that method should then localize\",\n \"type hints when subscripted (indexed) and are thus intended to annotate callables and\",\n \"this new class does *NOT* subclass the #first subscripted class. Instead: #* This\",\n \"hints that would then be implicitly supported by #any runtime type checker. At\",\n \"* NotIdenticalTo. # * LessThan. # * GreaterThan. # * Range. # *\",\n \"by @Saphyel at #32, add support for #additional classes support constraints resembling: #\",\n \"a runtime type #checker, you're probably *ONLY* using beartype. Right? That said, this\",\n \"from beartype.vale._is._valeis import _IsFactory from beartype.vale._is._valeistype import ( _IsInstanceFactory, _IsSubclassFactory, ) from beartype.vale._is._valeisobj\",\n \"each \\\"_BeartypeValidatorFactoryABC\\\" subclass will need # to additionally define and pass that callable\",\n \"str) and NonEmptyStringTest(obj) #* This new class would then be entirely empty. For\",\n \"import ArgumentParser\\\"). #!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! from beartype.vale._is._valeis import _IsFactory from beartype.vale._is._valeistype import ( _IsInstanceFactory, _IsSubclassFactory,\",\n \"when creating and returning # its \\\"BeartypeValidator\\\" instance. #FIXME: *BRILLIANT IDEA.* Holyshitballstime. The\",\n \"# from beartype import beartype # from beartype.is import Portable # NonEmptyStringTest =\",\n \"runtime type checker. At present, subscriptions of \\\"Is\\\" (e.g., #\\\"Annotated[str, Is[lambda text: bool(text)]]\\\")\",\n \"#FIXME: *BRILLIANT IDEA.* Holyshitballstime. The idea here is that we can #leverage all\",\n \"of classes declared by this submodule. ''' # ....................{ IMPORTS }.................... #!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! #\",\n \"to do so. So, this is probably actually useless. # #Nonetheless, the idea\",\n \"classes imported above for safety. del ( _IsFactory, _IsAttrFactory, _IsEqualFactory, _IsInstanceFactory, _IsSubclassFactory, )\",\n \"#Well, so much for brilliant. It's slow and big, so it seems doubtful\",\n \"will need to additionally accept a new # mandatory \\\"get_cause_or_none: Callable[[], Optional[str]]\\\" parameter,\",\n \"a PEP-compliant hierarchy of subscriptable (indexable) classes enabling callers to validate the internal\",\n \"type hints. #. Subscript those hints with (in order): #. The type of\",\n \"# * Choice. # * Language. # * Locale. # * Country. #\",\n \"complex scalars, data structures, and third-party objects. Like annotation objects defined by the\",\n \"Locale. # * Country. # * Currency. #* Comparison constraints # * IdenticalTo.\",\n \"submodule to generate human-readable #exception messages. Note that this implies that: #* The\",\n \"#technically improve portability by allowing users to switch between different #checkers... except not\",\n \"singleton accessed in the same way: e.g., # from beartype import beartype #\",\n \"Country. # * Currency. #* Comparison constraints # * IdenticalTo. # * NotIdenticalTo.\",\n \"supported by #any runtime type checker. At present, subscriptions of \\\"Is\\\" (e.g., #\\\"Annotated[str,\",\n \"using beartype. Right? That said, this would #technically improve portability by allowing users\",\n \"subscripted class. Instead: #* This new metaclass of this new class simply defines\",\n \"so. So, this is probably actually useless. # #Nonetheless, the idea itself is\",\n \"the difference between \\\"typing.Annotated\\\" and \\\"beartype.is.Portable\\\" #then? Simple. The latter dynamically generates one\",\n \"public module namespace, external attributes # should be locally imported at module scope\",\n \"an __isinstancecheck__() # dunder method. For the above example, this would be: #\",\n \"runtime type #checker, you're probably *ONLY* using beartype. Right? That said, this would\",\n \"beartype # from beartype.is import Portable # NonEmptyStringTest = Is[lambda text: bool(text)] #\",\n \"type of those parameters and returns. #. One or more subscriptions of classes\",\n \"#signature and docstring as the existing CauseSleuth.get_cause_or_none() #method. This new BeartypeValidator.get_cause_or_none() method should\",\n \"to additionally define and pass that callable when creating and returning # its\",\n \"beartype #infrastructure to do so. So, this is probably actually useless. # #Nonetheless,\",\n \"as _ArgumentParser\\\" rather # than merely \\\"from argparse import ArgumentParser\\\"). #!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! from beartype.vale._is._valeis\",\n \"= _IsInstanceFactory(basename='IsInstance') IsSubclass = _IsSubclassFactory(basename='IsSubclass') # Delete all private factory classes imported above\",\n \"I mean, if you're using a runtime type #checker, you're probably *ONLY* using\",\n \"explicitly covered by existing PEPs and thus *not* directly usable as annotations. Instead,\",\n \"to switch between different #checkers... except not really, since they'd still have to\",\n \"This new class would then be entirely empty. For the above example, this\",\n \"type checker. At present, subscriptions of \\\"Is\\\" (e.g., #\\\"Annotated[str, Is[lambda text: bool(text)]]\\\") are\",\n \"#* This new metaclass of this new class simply defines an __isinstancecheck__() #\",\n \"\\\"typing.Annotated\\\" and \\\"beartype.is.Portable\\\" #then? Simple. The latter dynamically generates one new PEP 3119-compliant\",\n \"TODO }.................... #FIXME: As intelligently requested by @Saphyel at #32, add support for\",\n \"At present, subscriptions of \\\"Is\\\" (e.g., #\\\"Annotated[str, Is[lambda text: bool(text)]]\\\") are only supported\",\n \"existing CauseSleuth.get_cause_or_none() #method. This new BeartypeValidator.get_cause_or_none() method should then be #called by the\",\n \"2014-2021 Beartype authors. # See \\\"LICENSE\\\" for further details. ''' **Beartype validators.** This\",\n \"parameter, which # that method should then localize to \\\"self.get_cause_or_none\\\". #* Each __class_getitem__()\",\n \"type hints that would then be implicitly supported by #any runtime type checker.\",\n \"and variables. Unlike annotation objects defined by the :mod:`typing` module, these classes are\",\n \"then be entirely empty. For the above example, this # would be: #\",\n \"Subscript those hints with (in order): #. The type of those parameters and\",\n \"#FIXME: As intelligently requested by @Saphyel at #32, add support for #additional classes\",\n \"the :mod:`typing` module (e.g., :attr:`typing.Union`), these classes dynamically generate PEP-compliant type hints when\",\n \"should be locally imported at module scope *ONLY* under alternate private # names\",\n \"import _IsAttrFactory from beartype.vale._is._valeisoper import _IsEqualFactory # ....................{ SINGLETONS }.................... # Public factory\",\n \"imported above for safety. del ( _IsFactory, _IsAttrFactory, _IsEqualFactory, _IsInstanceFactory, _IsSubclassFactory, ) #\",\n \"GreaterThan. # * Range. # * DivisibleBy. #FIXME: Add a new BeartypeValidator.get_cause_or_none() method\",\n \"existing \\\"beartype.is\\\" infrastructure to dynamically #synthesize PEP-compliant type hints that would then be\",\n \"authors. # See \\\"LICENSE\\\" for further details. ''' **Beartype validators.** This submodule publishes\",\n \"the same way: e.g., # from beartype import beartype # from beartype.is import\",\n \"# def munge_it(text: NonEmptyString) -> str: ... # #So what's the difference between\",\n \"to annotate callables and variables. Unlike annotation objects defined by the :mod:`typing` module,\",\n \"whenever subscripted. Clearly, this gets #expensive in both space and time consumption fast\",\n \"Like annotation objects defined by the :mod:`typing` module (e.g., :attr:`typing.Union`), these classes dynamically\",\n \"_IsFactory, _IsAttrFactory, _IsEqualFactory, _IsInstanceFactory, _IsSubclassFactory, ) # ....................{ TODO }.................... #FIXME: As intelligently\",\n \"order): #. The type of those parameters and returns. #. One or more\",\n \"by beartype #itself. Of course, does anyone care? I mean, if you're using\",\n \"approach. For safety, this new class does *NOT* subclass the #first subscripted class.\",\n \"hierarchy of subscriptable (indexable) classes enabling callers to validate the internal structure of\",\n \"NonEmptyStringTest(obj) #* This new class would then be entirely empty. For the above\",\n \"ArgumentParser as _ArgumentParser\\\" rather # than merely \\\"from argparse import ArgumentParser\\\"). #!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! from\",\n \"parameters and returns to be validated with :pep:`593`-compliant :attr:`typing.Annotated` type hints. #. Subscript\",\n \"private factory classes imported above for safety. del ( _IsFactory, _IsAttrFactory, _IsEqualFactory, _IsInstanceFactory,\",\n \"which # that method should then localize to \\\"self.get_cause_or_none\\\". #* Each __class_getitem__() dunder\",\n \"bool: # return isinstance(obj, str) and NonEmptyStringTest(obj) #* This new class would then\",\n \"Currency. #* Comparison constraints # * IdenticalTo. # * NotIdenticalTo. # * LessThan.\",\n \"# dunder method. For the above example, this would be: # class NonEmptyStringMetaclass(object):\",\n \"Is = _IsFactory(basename='Is') IsAttr = _IsAttrFactory(basename='IsAttr') IsEqual = _IsEqualFactory(basename='IsEqual') IsInstance = _IsInstanceFactory(basename='IsInstance') IsSubclass\",\n \"and docstring as the existing CauseSleuth.get_cause_or_none() #method. This new BeartypeValidator.get_cause_or_none() method should then\",\n \"# Delete all private factory classes imported above for safety. del ( _IsFactory,\",\n \"* LessThan. # * GreaterThan. # * Range. # * DivisibleBy. #FIXME: Add\",\n \"LICENSE )-------------------- # Copyright (c) 2014-2021 Beartype authors. # See \\\"LICENSE\\\" for further\",\n \"from beartype.vale._is._valeisobj import _IsAttrFactory from beartype.vale._is._valeisoper import _IsEqualFactory # ....................{ SINGLETONS }.................... #\",\n \"new PEP 3119-compliant #metaclass and associated class whenever subscripted. Clearly, this gets #expensive\",\n \"third-party objects. Like annotation objects defined by the :mod:`typing` module (e.g., :attr:`typing.Union`), these\",\n \"same way: e.g., # from beartype import beartype # from beartype.is import Portable\",\n \"#itself. Of course, does anyone care? I mean, if you're using a runtime\",\n \"#* The BeartypeValidator.__init__() method will need to additionally accept a new # mandatory\",\n \"order): #. Annotate callable parameters and returns to be validated with :pep:`593`-compliant :attr:`typing.Annotated`\",\n \"with :pep:`593`-compliant :attr:`typing.Annotated` type hints. #. Subscript those hints with (in order): #.\",\n \"as annotations. Instead, callers are expected to (in order): #. Annotate callable parameters\",\n \"_IsEqualFactory(basename='IsEqual') IsInstance = _IsInstanceFactory(basename='IsInstance') IsSubclass = _IsSubclassFactory(basename='IsSubclass') # Delete all private factory classes\",\n \"and \\\"beartype.is.Portable\\\" #then? Simple. The latter dynamically generates one new PEP 3119-compliant #metaclass\",\n \"objects defined by the :mod:`typing` module, these classes are *not* explicitly covered by\",\n \"and returning # its \\\"BeartypeValidator\\\" instance. #FIXME: *BRILLIANT IDEA.* Holyshitballstime. The idea here\",\n \"support for #additional classes support constraints resembling: # #* String constraints: # *\",\n \"def munge_it(text: NonEmptyString) -> str: ... # #So what's the difference between \\\"typing.Annotated\\\"\",\n \"publishes a PEP-compliant hierarchy of subscriptable (indexable) classes enabling callers to validate the\",\n \"at #32, add support for #additional classes support constraints resembling: # #* String\",\n \"the internal structure of arbitrarily complex scalars, data structures, and third-party objects. Like\",\n \"way: e.g., # from beartype import beartype # from beartype.is import Portable #\",\n \"as the existing CauseSleuth.get_cause_or_none() #method. This new BeartypeValidator.get_cause_or_none() method should then be #called\",\n \"beartype.vale._is._valeisobj import _IsAttrFactory from beartype.vale._is._valeisoper import _IsEqualFactory # ....................{ SINGLETONS }.................... # Public\",\n \"\\\"Is\\\" (e.g., #\\\"Annotated[str, Is[lambda text: bool(text)]]\\\") are only supported by beartype #itself. Of\",\n \"defines an __isinstancecheck__() # dunder method. For the above example, this would be:\",\n \"hints with (in order): #. The type of those parameters and returns. #.\",\n \"entirely empty. For the above example, this # would be: # class NonEmptyStringClass(object,\",\n \"#first subscripted class. Instead: #* This new metaclass of this new class simply\",\n \"by #any runtime type checker. At present, subscriptions of \\\"Is\\\" (e.g., #\\\"Annotated[str, Is[lambda\",\n \"....................{ IMPORTS }.................... #!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! # WARNING: To avoid polluting the public module namespace,\",\n \"variables. Unlike annotation objects defined by the :mod:`typing` module, these classes are *not*\",\n \"= _IsFactory(basename='Is') IsAttr = _IsAttrFactory(basename='IsAttr') IsEqual = _IsEqualFactory(basename='IsEqual') IsInstance = _IsInstanceFactory(basename='IsInstance') IsSubclass =\",\n \"the #first subscripted class. Instead: #* This new metaclass of this new class\",\n \"#Nonetheless, the idea itself is trivial. We declare a new #\\\"beartype.is.Portable\\\" singleton accessed\",\n \"(in order): #. The type of those parameters and returns. #. One or\",\n \"idea itself is trivial. We declare a new #\\\"beartype.is.Portable\\\" singleton accessed in the\",\n \"requested by @Saphyel at #32, add support for #additional classes support constraints resembling:\",\n \"This new BeartypeValidator.get_cause_or_none() method should then be #called by the \\\"_peperrorannotated\\\" submodule to\",\n \"really, since they'd still have to import beartype #infrastructure to do so. So,\",\n \"....................{ SINGLETONS }.................... # Public factory singletons instantiating these private factory classes. Is\",\n \"_IsFactory from beartype.vale._is._valeistype import ( _IsInstanceFactory, _IsSubclassFactory, ) from beartype.vale._is._valeisobj import _IsAttrFactory from\",\n \"Clearly, this gets #expensive in both space and time consumption fast -- which\",\n \"Instead: #* This new metaclass of this new class simply defines an __isinstancecheck__()\",\n \"type #checker, you're probably *ONLY* using beartype. Right? That said, this would #technically\",\n \"would then be implicitly supported by #any runtime type checker. At present, subscriptions\",\n \"*not* explicitly covered by existing PEPs and thus *not* directly usable as annotations.\",\n \"* IdenticalTo. # * NotIdenticalTo. # * LessThan. # * GreaterThan. # *\",\n \"at module scope *ONLY* under alternate private # names (e.g., \\\"from argparse import\",\n \"(in order): #. Annotate callable parameters and returns to be validated with :pep:`593`-compliant\",\n \"implies that: #* The BeartypeValidator.__init__() method will need to additionally accept a new\",\n \"allowing users to switch between different #checkers... except not really, since they'd still\",\n \"Comparison constraints # * IdenticalTo. # * NotIdenticalTo. # * LessThan. # *\",\n \"would be: # class NonEmptyStringClass(object, metaclass=NonEmptyStringMetaclass): # pass # #Well, so much for\",\n \"by the \\\"_peperrorannotated\\\" submodule to generate human-readable #exception messages. Note that this implies\",\n \"\\\"_peperrorannotated\\\" submodule to generate human-readable #exception messages. Note that this implies that: #*\",\n \"Range. # * DivisibleBy. #FIXME: Add a new BeartypeValidator.get_cause_or_none() method with the same\",\n \"metaclass of this new class simply defines an __isinstancecheck__() # dunder method. For\",\n \"and returns. #. One or more subscriptions of classes declared by this submodule.\",\n \"for further details. ''' **Beartype validators.** This submodule publishes a PEP-compliant hierarchy of\",\n \"# See \\\"LICENSE\\\" for further details. ''' **Beartype validators.** This submodule publishes a\",\n \"with (in order): #. The type of those parameters and returns. #. One\",\n \"**Beartype validators.** This submodule publishes a PEP-compliant hierarchy of subscriptable (indexable) classes enabling\",\n \"only supported by beartype #itself. Of course, does anyone care? I mean, if\",\n \"avoid polluting the public module namespace, external attributes # should be locally imported\",\n \"would be: # class NonEmptyStringMetaclass(object): # def __isinstancecheck__(cls, obj) -> bool: # return\",\n \"internal structure of arbitrarily complex scalars, data structures, and third-party objects. Like annotation\",\n \"from beartype.vale._is._valeisoper import _IsEqualFactory # ....................{ SINGLETONS }.................... # Public factory singletons instantiating\",\n \"IsInstance = _IsInstanceFactory(basename='IsInstance') IsSubclass = _IsSubclassFactory(basename='IsSubclass') # Delete all private factory classes imported\",\n \"# Copyright (c) 2014-2021 Beartype authors. # See \\\"LICENSE\\\" for further details. '''\",\n \"That said, this would #technically improve portability by allowing users to switch between\",\n \"new # mandatory \\\"get_cause_or_none: Callable[[], Optional[str]]\\\" parameter, which # that method should then\",\n \"this new class simply defines an __isinstancecheck__() # dunder method. For the above\",\n \"are only supported by beartype #itself. Of course, does anyone care? I mean,\",\n \"does anyone care? I mean, if you're using a runtime type #checker, you're\",\n \"that this implies that: #* The BeartypeValidator.__init__() method will need to additionally accept\",\n \"*BRILLIANT IDEA.* Holyshitballstime. The idea here is that we can #leverage all of\",\n \"(c) 2014-2021 Beartype authors. # See \\\"LICENSE\\\" for further details. ''' **Beartype validators.**\",\n \"to dynamically #synthesize PEP-compliant type hints that would then be implicitly supported by\",\n \"PEPs and thus *not* directly usable as annotations. Instead, callers are expected to\",\n \"IdenticalTo. # * NotIdenticalTo. # * LessThan. # * GreaterThan. # * Range.\",\n \"won't #be the default approach. For safety, this new class does *NOT* subclass\",\n \"validated with :pep:`593`-compliant :attr:`typing.Annotated` type hints. #. Subscript those hints with (in order):\",\n \"__isinstancecheck__(cls, obj) -> bool: # return isinstance(obj, str) and NonEmptyStringTest(obj) #* This new\",\n \"safety. del ( _IsFactory, _IsAttrFactory, _IsEqualFactory, _IsInstanceFactory, _IsSubclassFactory, ) # ....................{ TODO }....................\",\n \"IsAttr = _IsAttrFactory(basename='IsAttr') IsEqual = _IsEqualFactory(basename='IsEqual') IsInstance = _IsInstanceFactory(basename='IsInstance') IsSubclass = _IsSubclassFactory(basename='IsSubclass') #\",\n \"* Currency. #* Comparison constraints # * IdenticalTo. # * NotIdenticalTo. # *\",\n \"new class does *NOT* subclass the #first subscripted class. Instead: #* This new\",\n \"For the above example, this would be: # class NonEmptyStringMetaclass(object): # def __isinstancecheck__(cls,\",\n \"and returns to be validated with :pep:`593`-compliant :attr:`typing.Annotated` type hints. #. Subscript those\",\n \"Add a new BeartypeValidator.get_cause_or_none() method with the same #signature and docstring as the\",\n \"method will need to additionally accept a new # mandatory \\\"get_cause_or_none: Callable[[], Optional[str]]\\\"\",\n \"the same #signature and docstring as the existing CauseSleuth.get_cause_or_none() #method. This new BeartypeValidator.get_cause_or_none()\",\n \"except not really, since they'd still have to import beartype #infrastructure to do\",\n \"LessThan. # * GreaterThan. # * Range. # * DivisibleBy. #FIXME: Add a\",\n \"declared by this submodule. ''' # ....................{ IMPORTS }.................... #!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! # WARNING: To\",\n \"switch between different #checkers... except not really, since they'd still have to import\",\n \"return isinstance(obj, str) and NonEmptyStringTest(obj) #* This new class would then be entirely\",\n \"parameters and returns. #. One or more subscriptions of classes declared by this\",\n \"and thus *not* directly usable as annotations. Instead, callers are expected to (in\",\n \"of arbitrarily complex scalars, data structures, and third-party objects. Like annotation objects defined\",\n \"beartype.vale._is._valeisoper import _IsEqualFactory # ....................{ SINGLETONS }.................... # Public factory singletons instantiating these\",\n \"with the same #signature and docstring as the existing CauseSleuth.get_cause_or_none() #method. This new\",\n \"The latter dynamically generates one new PEP 3119-compliant #metaclass and associated class whenever\",\n \"# pass # #Well, so much for brilliant. It's slow and big, so\"\n]","isConversational":false}}}],"truncated":false,"partial":false},"paginationData":{"pageIndex":44,"numItemsPerPage":100,"numTotalItems":12866649,"offset":4400,"length":100}},"jwt":"eyJhbGciOiJFZERTQSIsImtpZCI6Im1sR1pFYktIVHRVSGRhX1RRdEczQ0N1S3k5ME9Qd25DNHY5elRjM3FVYzgifQ.eyJyZWFkIjp0cnVlLCJwZXJtaXNzaW9ucyI6eyJyZXBvLmNvbnRlbnQucmVhZCI6dHJ1ZX0sImlhdCI6MTc4MzU4MjI0MCwianRpIjoiOWYzNjljOTMtZjY3ZC00ZWNlLTk0NDMtNzQ1ZThjMzBjNTZjIiwic3ViIjoiL2RhdGFzZXRzL3RlcnJ5eXovc3RhcmNvZGVyZGF0YV9uZ3JhbV8xMyIsImV4cCI6MTc4MzU4NTg0MCwiaXNzIjoiaHR0cHM6Ly9odWdnaW5nZmFjZS5jbyJ9.O9CjihATBJTDQOTD7EANH-GVFvv9EjcAHWqKCnYq7sQqHMbM2rzpe_lnJljQXVJiJFBbUvUIJYMF3QIRLMFzCw","displayUrls":true,"splitSizeSummaries":[{"config":"default","split":"train","numRows":12866649,"numBytesParquet":149232926747}]},"discussionsStats":{"closed":0,"open":0,"total":0},"fullWidth":true,"hasGatedAccess":true,"hasFullAccess":true,"isEmbedded":false,"savedQueries":{"community":[],"user":[]}}">
ngram listlengths 0 67.8k |
|---|
[
"when calling the function, can be removed in the future \"\"\" def test_sample_attack():",
"from privacy_evaluator.attacks.sample_attack import Sample_Attack \"\"\" This test only test if no error is",
"removed in the future \"\"\" def test_sample_attack(): test = Sample_Attack(0, 0, 0) test.perform_attack()",... |
[
"writing, software # distributed under the License is distributed on an \"AS IS\"",
"\"\"\"), license='Apache 2.0', classifiers=[ 'Development Status :: 4 - Beta', 'Intended Audience ::",
"the Presto distributed SQL Engine', long_description=textwrap.dedent(\"\"\" Client for Presto (https://prestodb.io), a dist... |
[
"\"Discrete Mathematics\", \"Adv Engineering Mathematics\", \"Linear Algebra\", \"Cryptography\"] weightage = [250,900,850,1200,290,345] seperator =",
"as graph subject = [\"Probability\", \"Calculas\", \"Discrete Mathematics\", \"Adv Engineering Mathematics\", \"Linear Algebra\",",
"Mathematics\", \"Linear Alg... |
[
"parameter values to evaluate for each of the algorithms \"\"\" # Question 6",
"for lam in ran: rg = learner(lam) train_score, validation_score = cross_validate(rg, train_X.to_numpy(), train_y.to_numpy(),",
"train_err = [] validation_err = [] for lam in ran: rg = learner(lam)",
"as gg def select_polynomial_de... |
[
"version of the source content :type content_version: string :return: a list of formats",
"the catalog :param media: the media object :type media: dict :param content_version: the",
"isinstance(target, int): return target else: raise Exception('Invalid replacement target \"{}\". Expected string but",
"a book ... |
[
"return utils.get_log(self) def workflow_is_finished(self): state = self.get_state() if not state.transitions.all(): return True else:",
"utils.import_from_string(transition.condition) # todo:目前这里是轮询到条件正确的一个, 就跳出轮询设置状态了 if not cond().run(self, transition): continue if transition.task: # todo:task是顺序还是异步执行,",
"g... |
[
"name=None, duration_field=None, **kwargs): self.duration_field = duration_field super(VideoField, self).__init__(verbose_name, name, **kwargs) def check(self, **kwargs):",
"def __init__(self, verbose_name=None, name=None, duration_field=None, **kwargs): self.duration_field = duration_field super(VideoField, self... |
[
"@staticmethod def array2BST(array): ''' array:sorted array ''' n = len(array) if n ==",
"array:sorted array ''' n = len(array) if n == 0: return None m",
"n = len(array) if n == 0: return None m = n//2 left,root,right",
"= len(array) if n == 0: return None m = n//2 left,root,right =",
"@staticmethod def BS... |
[
"@pytest.mark.parametrize('spec_file,spec_name', [ ('experimental/reinforce.json', 'reinforce_mlp_cartpole'), ('experimental/reinforce.json', 'reinforce_rnn_cartpole'), # ('experimental/reinforce.json', 'reinforce_conv_breakout'), ]) def test_reinforce(spec_file, spec_name):",
"test_hydra_dqn(spec_file, spec_name... |
[
"group\")) new_groups = app.group.get_group_list() assert len(old_groups) == len(new_groups) def test_modify_group_header(app): if app.group.count() ==",
"Group def test_modify_group_name(app): if app.group.count() == 0: app.group.create(Group(name=\"test\")) old_groups = app.group.get_group_list() app.group.modi... |
[
"= ResponseInfoWrapper( response_headers, response_status, res_ctype, res_clength, data.decode(\"utf-8\"), ) # Send off data to",
"yourself under normal circumstances. \"\"\" response_headers = {} response_status = 0 iterable =",
"the current WSGI application, which will be wrapped config (MetricsApiConfig): In... |
[
"= max(epsilon, 0) return take_action # Ignore sklearn warnings def warn(*args, **kwargs): pass",
"sorted_list = [(y,x) for x,y in action_list.items()] sorted_list.sort(reverse=True) take_action = sorted_list[0][1] else: #",
"= NearestNeighbors(n_neighbors=min(k,max_iters)).fit(states[:max_iters]) distances, in... |
[
"self.es.indices.delete(index=self.blocks_index_name) self.es.indices.create(index=self.blocks_index_name, body=self.block_mapping) except elasticsearch.ElasticsearchException as es1: print(\"Elastic exception on create Indicies:\", es1)",
"\"mappings\": { \"balance\": { \"properties\": { \"@dtime\": { \"type\": ... |
[
"def testCleanPhoneNumber(self): phone_number = \" 324 23-23421241\" cleaned = clean_phone_number(phone_number) self.assertEquals(cleaned, \"+3242323421241\") def",
"pass def testCleanPhoneNumber(self): phone_number = \" 324 23-23421241\" cleaned = clean_phone_number(phone_number) self.assertEquals(cleaned, \"+32... |
[
"= complex_energy - (frag1_energy + frag2_energy) return tf.expand_dims(binding_energy, axis=1) class AtomicConvModel(KerasModel): \"\"\"Implements an",
"enumerate( dataset.iterbatches( batch_size, deterministic=True, pad_batches=pad_batches)): N = self.complex_num_atoms N_1 = self.frag1_num_atoms N_2 =",
"rang... |
[
"AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,",
"copyright notice and this permission notice shall be included in all copies or",
"= YamlConfigurationFile() self.assertIsNotNone(yaml) yaml.load_from_text(\"\"\" brain: oobs: default: \"\"\", ConsoleConfiguration(), \".\") bra... |
[
"that create specific orb types (whether board change, orb change, orb spawn, etc)",
"for active skills that create specific orb types (whether board change, orb change,",
"active skills that create specific orb types (whether board change, orb change, orb",
"Interface for active skills that create specific o... |
[
"fixed_package_name.startswith('backports_'): fixed_package_name.replace('_', '.', 1) return fixed_package_name def _write_init_py(package_name: str) -> None: \"\"\" Dynamically",
":return: tuple of the README.md text and the long_description type. :rtype: typing.Tuple[str, str]",
"Python :: 3.7', 'Programming ... |
[
"np.linalg.norm(pi_dag.sum(axis = 1) - mu, 1)) print('error_nu = %.5e' % np.linalg.norm(pi_dag.sum(axis = 0)",
"print('error_nu = %.5e' % np.linalg.norm(pi_dag.sum(axis = 0) - nu, 1)) print('fvall = %.5e'",
"- r.sum() / (m + n + 1)) / (n + 1)).reshape((m, 1))",
"mu, 1)) print('error_nu = %.5e' % np.linalg.nor... |
[
"argparse.ArgumentParser(description='Clean up the data for a given parameter') parser.add_argument('--infile', help=\"Path to the VCF",
"VCF file\", default='test.vcf') parser.add_argument('--outfile', help=\"Path to the new VCF file\", default='test.out.vcf') parser.add_argument('--param', help=\"Parameter",
... |
[
"= 0 for trans in self.corpus.iter_transcripts(): self.trans_num += 1 self.da2num = switchboard_da_mapping() #",
"prev_speaker = speaker i += 1 segment_indices[j] = i return segment_indices def swda_half_perturb(self,",
"permutations, only the uniquely possible ones are returned \"\"\" assert len(sents) == len(... |
[
"test_clean_accounting_column(): test_str = \"(1,000)\" assert _clean_accounting_column(test_str) == float(-1000) @pytest.mark.utils def test_clean_accounting_column_zeroes(): test_str =",
"def test_clean_accounting_column(): test_str = \"(1,000)\" assert _clean_accounting_column(test_str) == float(-1000) @pytest... |
[
"import requests import requests_cache import re import time from bs4 import BeautifulSoup from",
"link if SEARCH_RESULT['WIKI']['link'] != NO_RESULT and SEARCH_RESULT['YOUTUBE']['link'] != NO_RESULT: break SEARCH_RESULT['FIRST']['title'] = results[0].get('title')",
"\"link\": link } results.append(item) #print... |
[
"after_course.appendChild(course_name) with open(file_path, 'wb+') as f: f.write(doc.toprettyxml(indent='\\t', encoding='utf-8')) def load_data_xml(file_path): info_list = []",
"self.pre_node_titles = pre_node_titles def save_data_xml(course_list, file_path): doc = Document() courses = doc.createElement('course_l... |
[
"from theheck.types import Command @pytest.fixture def output(target): return ('error: the following file has",
"rm foo bar', 'git rm']) def test_not_match(script): assert not match(Command(script, '')) @pytest.mark.parametrize('script, target,",
"rm']) def test_not_match(script): assert not match(Command(scrip... |
[
"async def redoc_html(): return get_redoc_html( openapi_url=data_service_app.openapi_url, title=data_service_app.title + \" - ReDoc\", redoc_js_url=\"/static/redoc.standalone.js\", )",
"from fastapi.staticfiles import StaticFiles from starlette.responses import PlainTextResponse, Response from data_service.api.da... |
[
"str(walk_iteration + 1) + \"/\" + str(num_walks) ) self.random_state.shuffle(nodes) for node in nodes:",
"= new_id_map self.is_directed = self.graph.is_directed() self.p = return_hyperparameter self.q = inout_hyperparameter self.random_state =",
"reference implementation of node2vec comes from Aditya Grover fr... |
[
"= re.sub(r'[^A-z0-9]', '', messages[2]) if messages[3][0] == self.symbol: messages = [\"\"] + messages",
"command = getattr(commands, \"command_{}\".format(cmd), __name__)(args, room.strip().lower(), user.lower(), self) self.ws.send(\"{}|{}\".format(room, command)) except (IndexError, TypeError):",
"\"name\": ... |
[
"X = model.points if spatial_key is None else model[spatial_key] if rd_method == \"ElPiGraph\":",
"import Optional, Tuple, Union import numpy as np import pandas as pd import",
"np.ndarray, NumNodes: int = 50, **kwargs, ) -> Tuple[np.ndarray, np.ndarray]: \"\"\" Generate a",
"tree model, which contains the fo... |
[
"model.group import Group import pytest import allure_pytest def test_add_group(app, db, check_ui, json_groups): group0",
"db, check_ui, json_groups): group0 = json_groups #with pytest.allure.step(\"Given a group list\"): old_groups =",
"the list\" % group0): app.group.create(group0) #assert app.group.count() =... |
[
"cls.frames[frame_id] = frame print(frame_id, frame) @classmethod def find_frames(cls, position: CursorPosition) -> list[Frame]: \"\"\"",
"def find_frames(cls, position: CursorPosition) -> list[Frame]: \"\"\" Right now it's a fake implementation,",
"callee frames of the same caller frame. Nodes are also indexed... |
[
"API to use: '1.0', '1.1', or '2.0'. (Default: '2.0') .. attribute:: use_ssl *BooleanField*:",
"use_ssl = models.BooleanField( default=False, verbose_name=\"Use SSL\", help_text=\"Use HTTPS API URLs by default?\" )",
"api_key *CharField*: Your base64-encoded API key, used to sign requests. This is optional",
... |
[
"\"inventory_blue_item\": return HsvFilter(79, 169, 0, 109, 246, 188, 0, 0, 0, 0) if",
"1260, 210] if object_name == \"player_map_loc\": if kwargs.get(\"big_map\"): return HsvFilter(31, 94, 86, 73,",
"20), [415, 533, 888, 700] if object_name == \"loot_chest_normal\": # This is a",
"0, 0, 0, 0) if object_name ... |
[
"state.comp = data.id['x'] assert state.n_bin == 12 state.n_bin = 11 state.comp = data.id['y']",
"self.helper.upper == +100 def test_change_percentile(self): # Changing scale mode updates the limits self.helper.percentile",
"8 self.state.comp = self.data.id['y'] assert self.state.x_min == 1.5 assert self.state.... |
[
"import Iterable, Optional class ProductsNotFound(Exception): def __init__(self, product_ids: Optional[Iterable[int]] = None): self.product_ids =",
"self.product_ids = product_ids or [] self.message = \"One or more products are invalid.\"",
"ProductsNotFound(Exception): def __init__(self, product_ids: Optional[... |
[
"999) def test_record_items(self): r = Record([\"name\", \"age\", \"married\"], [\"Alice\", 33, True]) self.assertEqual(r.items(), [(\"name\",",
"KIND, either express or implied. # See the License for the specific language",
"Unless required by applicable law or agreed to in writing, software # distributed",
... |
[
"db = ExplainerDashboard(explainer, title=\"testing\", responsive=False) dash_duo.start_server(db.app) dash_duo.wait_for_text_to_equal(\"h1\", \"testing\", timeout=30) assert dash_duo.get_logs() == [],",
"= ClassifierExplainer(model, X_test, y_test, cats=['Sex', 'Deck'], labels=['Queenstown', 'Southampton', 'Cher... |
[
"in input dir {1}\".format(len(files),inputDataDir)) print(\"First is {0}\".format(files[0])) ds = tfDsParquet.create_parquet_dataset([files[0]]) for element in",
"{0}\".format(sampleId)) #print(sampleIds.shape) #print(pixels.shape) # a += 1 # if a > 10: #",
"sampleId.decode(\"utf-8\") fileName = os.path.join(o... |
[
"= val2[:index] + '&&' + val2[index+2:] else: val = val2 xrcgen.DefaultXrcObject.write_property(self, name, val,",
"def cn(self, name): # don't process already formatted items again if name.startswith('wx.'): return",
"to be supported fully: if compat.IS_PHOENIX: import_modules = ['import wx.adv\\n'] if compat.... |
[
"config import config, gen_config, update_config_from_args, s_args config = update_config_from_args(config, s_args) def main(): #",
"train_metric, epoch, config, logger=logger, ctx=ctx) validNet(net, valid_data_iter, loss, eval_metric, epoch, config, logger=logger, ctx=ctx)",
"config and mkdir output logger, fi... |
[
"default=128, help=\"feat dimension\") parser.add_argument(\"--feature_layer\", type=str, default='lowdim', help=\"feature layer\") parser.add_argument('--use-lmdb', action='store_true') args = parser.parse_args()",
"get_dino_network(args.backbone, pretrained_path, feature_layer=args.feature_layer) elif args.task... |
[
"def test_find_data_corrupt_pom(self): content = \"\"\" </project> </project> <dependencyManagement> <dependencies> <dependency> <groupId>grp1.id</groupId> <artifactId>art1.id</artifactId> </dependency>",
"[d.group_id for d in deps] assert not {'grp1.id', 'grp2.id', 'grp3.id'}.difference(set(group_ids)) scopes = ... |
[
"import os import sys import unittest from tests.tests_bin_class.test_performance import * if __name__ ==",
"import sys import unittest from tests.tests_bin_class.test_performance import * if __name__ == \"__main__\": unittest.main()",
"os import sys import unittest from tests.tests_bin_class.test_performance i... |
[
"to do consistency/sanity checks on Allocations. ''' def runtask(self): ''' ''' self.log.info(\"Running task",
"checks on Allocations. ''' def runtask(self): ''' ''' self.log.info(\"Running task %s\" % self.section)",
"#!/usr/bin/env python from vc3master.task import VC3Task class CheckAllocations(VC3Task): '''... |
[
"{ 'TIMEOUT': 5, 'USE_SSL': False, } @property def url(self): scheme = 'http' if",
"request=None): _, _, trace = sys.exc_info() notice_em = etree.Element('notice', version='2.0') tb = traceback.extract_tb(trace)",
"= traceback.extract_tb(trace) api_key = etree.SubElement(notice_em, 'api-key').text = self.settin... |
[
"['SnapshotConnector'] _LOGGER = logging.getLogger(__name__) class SnapshotConnector(AzureConnector): def __init__(self, **kwargs): super().__init__(**kwargs) self.set_connect(kwargs.get('secret_data')) def list_snapshots(self):",
"SnapshotConnector(AzureConnector): def __init__(self, **kwargs): super().__init__(... |
[
"punctuation: str @dataclass class Greeter: punctuation: str greeting: str = 'Hello' def __call__(self,",
"FrenchCustomer, pass into the \"greet_customer\" interaction, # then test the result. french_customer =",
"using its class for the \"key\" registry.register_factory(default_greeter_factory, Greeter) # Now ... |
[
"and runs the repair method :param time: the simulation time object :param gas_field:",
"and repair costs associated with all detection and repair methods in the program.",
"and repair methods must be defined by the dispatch_objects specified for each method.",
"+ ' ' + tech.dispatch_object.name] = tech.dispa... |
[
"self.G_A2B = modelGenerator(conv_kernel_c7Ak=7, use_resize_convolution=self.use_resize_convolution, input=self.image_shapeA, output=self.image_shapeB, name='G_A2B_model') self.G_B2A = modelGenerator(conv_kernel_c7Ak=7, use_resize_convolution=self.use_resize_convolution, input=self.image_shapeB, output=self.image_s... |
[
"templates = Jinja2Templates(directory=\"templates\") #views @app.get(\"/\", tags=[\"/view\"]) async def index(request: Request): return templates.TemplateResponse(\"index.html\", {\"request\":",
"configure static and templates file on jinja 2 app = FastAPI( title=f\"Technical Case\",",
"para subir planilhas pa... |
[
"def f(x): return client.scripts.put_sql_archive(script_id, True) fut.add_done_callback(f) fut.result() outputs = client.scripts.get_sql_runs(script_id, run_id)[\"output\"] if not",
"existing_table_rows is \"upsert\", delayed executions move data from staging table to final table",
"ID of the database credentia... |
[
"def test_badge_str(self): strategy = BADGE(2) expected_str = 'BADGE(num_classes=2)' self.assertEqual(expected_str, str(strategy)) @pytest.mark.pytorch class ExpectedGradientLengthTest(unittest.TestCase):",
"batch_size=100, device='cpu') self.assertEqual(4, strategy.num_classes) self.assertEqual(100, strategy.bat... |
[
"] def parse_tango_color(c): r = int(c[:4][:2], 16) g = int(c[4:8][:2], 16) b =",
"parse_tango_color(c): r = int(c[:4][:2], 16) g = int(c[4:8][:2], 16) b = int(c[8:][:2], 16)",
"color_table): cfg.default_foreground_color = parse_tango_color('eeeeeeeeecec') cfg.default_background_color = parse_tango_color('32323... |
[
"auth_code_data is None: return None auth_code = DbAuthorizationCode.validate_document(auth_code_data) if auth_code.is_expired(): return None return",
"class OpenIDCode(UserInfoMixin, ExistsNonceMixin, JwtConfigMixin, _OpenIDCode): jwt_token_expiration = config.oauth2.token_expiration.authorization_code class Ope... |
[
"None self.backlog = backlog self.listener = None self.protocols = {} async def start(self)",
"self.backlog = backlog self.listener = None self.protocols = {} async def start(self) ->",
"-> None: \"\"\" Send a message. :param msg: A bytes object representing the",
"Start the server \"\"\" try: self.listener =... |
[
"specify a key, so this finding shouldn't be accessed by key. Randomise it",
"triggers for example stop_processing: bool = False _scheduler: Optional[PlaybooksScheduler] = None def set_scheduler(self,",
"from enum import Enum from typing import List, Optional, Dict, Any from dataclasses",
"MANUAL_TRIGGER = 3 ... |
[
"= ObjectIdField() name = StringField() brand = StringField() year = StringField() size =",
"mongoengine import Document from mongoengine.fields import ( FloatField, StringField, ListField, URLField, ObjectIdField, )",
"{\"collection\": \"bike\"} ID = ObjectIdField() name = StringField() brand = StringField() y... |
[] |
[
"self: This instance with matching fixedClassifier resources retrieved from the server available through",
"error condition \"\"\" return self._select(self._map_locals(self._SDM_ATT_MAP, locals())) def read(self, href): \"\"\"Retrieves a single instance",
"TO THE WARRANTIES OF MERCHANTABILITY, # FITNESS FOR A P... |
[
"= np.int16(self._coefD >> 16) secondHalf = np.int16(self._coefD & 0xffff) # Set the minimum",
"libc # libc = m.SacherLasaTeknique() # print(libc.vcs()) # eposlib = ctypes.windll.eposcmd eposlib =",
"* 1)() ObjectData = ctypes.cast(ObjectDataArray, ctypes.POINTER(ctypes.c_int32)) StoredPositionNbBytesRead = cty... |
[
"[ 'image/{}', 'image/{}_crop' ] label_dirs = [ 'label/{}/annotations', 'label/{}/annotations_crop', ] def generate(root): assert",
"] label_dirs = [ 'label/{}/annotations', 'label/{}/annotations_crop', ] def generate(root): assert len(image_dirs) == len(label_dirs)",
"label_path)): image = label.replace('.png'... |
[
"same arguments and perform the same operation torch_module = torch.nn.Unfold( kernel_size, dilation=dilation, padding=padding,",
"1 padding = 1 stride = 2 # both modules accept the same",
"comparison with ``torch.nn.Unfold``.\"\"\" # imports, make this example deterministic import torch import unfoldNd",
"di... |
[
"'\\\\u0026', } _json_escapes_attr = { ord('>'): '\\\\u003E', ord('<'): '\\\\u003C', ord('&'): '\\\\u0026', ord('\"'): '"',",
"ord('\"'): '"', ord(\"'\"): ''', ord(\"=\"): '=', } @keep_lazy(str, SafeText) def escapejson(value): \"\"\"Hex encodes",
"script.\"\"\" return mark_safe(force_str(value)... |
[
"} class PlotlyAPI(Chart): \"\"\" Base class for Plotly.js API This class is used",
"options = { \"chartid\": chart_id, \"url\": url, \"params\": init_params } super(PlotlyAPI, self).__init__(\"PlotlyAPI\", options,",
"have a default method of transmitting data. Instead the user must supply a",
"\"showLink\":... |
[
"Example(QtGui.QWidget): def __init__(self): super(Example, self).__init__() self.initUI() def initUI(self): qbtn = QtGui.QPushButton('Quit', self) qbtn.clicked.connect(QtCore.QCoreApplication.instance().quit)",
"super(Example, self).__init__() self.initUI() def initUI(self): qbtn = QtGui.QPushButton('Quit', self... |
[
"from gpytorch.means import ZeroMean class TestZeroMean(unittest.TestCase): def setUp(self): self.mean = ZeroMean() def test_forward(self):",
"__future__ import division from __future__ import print_function from __future__ import unicode_literals import torch",
"self.assertTrue(res.eq(0).all()) def test_forwar... |
[
"birthday=\"\", anniversary=\"\", secondary_address=\"\", secondary_tel=\"\", notes=\"\")] + [ Contact(first_name=random_string('first_name', 10), middle_name=random_string('middle_name', 10), last_name=random_string('last_name', 10),",
"anniversary=\"\", secondary_address=\"\", secondary_tel=\"\", notes=\"\")] +... |
[
"Added cousin package:\", cousin_dir nephew_fname = os.path.join(cousin_dir, \"nephew\"+os.extsep+\"py\") nephew_file = open(nephew_fname, \"w\") nephew_file.close()",
"= run_module(mod_name, run_name=run_name) # Read from bytecode self.failUnless(\"__package__\" in d2) self.failUnless(d2[\"__package__\"] == pkg_... |
[
"is_extension=False, extension_scope=None, serialized_options=None, file=DESCRIPTOR), _descriptor.FieldDescriptor( name='dtype', full_name='ImageData.dtype', index=3, number=4, type=9, cpp_type=9, label=1, has_default_value=False,",
"\\x01(\\x05\\x12\\r\\n\\x05\\x64type\\x18\\x04 \\x01(\\t\\\"!\\n\\x0fPredictionC... |
[
"(completed.c.discount_code_id == discounts.c.discount_code_id) & (completed.c.marketer_id == discounts.c.marketer_id)) \\ .outerjoin(placed, (placed.c.event_id == discounts.c.event_id) &",
"sales (dictionary with total sales and ticket count) for placed, completed and pending",
"methods = ['GET'] decorators = ... |
[
"import Language class SerbianDefaults(Language.Defaults): tokenizer_exceptions = TOKENIZER_EXCEPTIONS lex_attr_getters = LEX_ATTRS stop_words = STOP_WORDS",
".tokenizer_exceptions import TOKENIZER_EXCEPTIONS from .lex_attrs import LEX_ATTRS from ...language import Language class SerbianDefaults(Language.Defaults... |
[
".functions.deform_pool import deform_roi_pooling from .modules.deform_conv import (DeformConv, ModulatedDeformConv, DeformConvPack, ModulatedDeformConvPack) from .modules.deform_pool import",
"import deform_roi_pooling from .modules.deform_conv import (DeformConv, ModulatedDeformConv, DeformConvPack, ModulatedDe... |
[
"def get_skill_value_list(obj): return SkillValue.get_value_list(obj.skill_value_id) class Costar(object): def __init__(self, name, count): self.name = name",
"from data.models import Skill, SkillValue class ListSerializer(serializers.ModelSerializer): skill_value_list = serializers.SerializerMethodField(read_onl... |
[
"by 'image_GreyScale.shape + tuple([3])' we add one more element '3' to the tuple",
"three channels image_GreyScale_with_3_channels[:, :, 0] = x[:, :, 0] image_GreyScale_with_3_channels[:, :, 1] =",
"# Checking that image was written with three channels and they are identical",
"Adjusting third subplot ax2.im... |
[
"def render(nodes, edges, output_name): color_map = roles_to_color_map(edges=edges) formatted_nodes, formatted_edges = format_graph(nodes, edges, color_map)",
"node.name, 'type': node.node_type, 'icon': { 'face': 'Font Awesome 5 Free', 'code': node.get_font_code(), 'size':",
"description = get_description(node)... |
[
"INRIA # Copyright (c) 2018, University of Lille # All rights reserved. #",
"and the following disclaimer in the documentation # and/or other materials provided with",
"# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR #",
"'model', help='specify data type that will be storen in the... |
[
"on None\" assert self.is_compatible_with(phase), \"`%r` is not compatible with phase `%r`\" % (self,",
"found in the LICENSE file. from mvc.models.properties import StringProperty from pyxrd.generic.io.custom_io import storables,",
"InSituBehaviour(DataModel, RefinementGroup, Storable): \"\"\" Interface class ... |
[
"\", xPos, \" Y = \", yPos) # returns -1, 0, 1 with",
"xPos = 40 yPos = 40 # the action for i in range(100):",
"return random.randint(-1, 1) SimpleBug() \"\"\" you can eliminate the randomMove() function substituting xPos",
"function substituting xPos += randomMove() yPos += randomMove() with xPos += random.r... |
[
"coin: if d[m-coin]+1 < min_coin: min_coin = d[m-coin]+1 d[m] = min_coin #print d",
"if m >= coin: if d[m-coin]+1 < min_coin: min_coin = d[m-coin]+1 d[m] =",
"coin_list = [24,13,12,7,5,3,1] #coin_list = map(int, open('dataset_71_8.txt').read().split(',')) d = {0:0} for m in",
">= coin: if d[m-coin]+1 < min_co... |
[
"from txbibtex import bibentry_str BIB_FILE = 'references.bib' bibfile = metamodel_for_language('bibtex').model_from_file(BIB_FILE) # Drop line",
"Remove comments from bib file. \"\"\" from textx import metamodel_for_language from txbibtex import",
"file. \"\"\" from textx import metamodel_for_language from txb... |
[
"# # Licensed under the Apache License, Version 2.0 (the \"License\"); # you",
"writing, software # distributed under the License is distributed on an \"AS IS\"",
"to build args based on different API version.\"\"\" messages = apis.GetMessagesModule('compute', api_version) flags.MakeResourcePolicyArg().AddArgum... |
[
".papers import Papers from .researchers import Researchers def ResearchersFile(filename): \"\"\"Parse a file containing",
"containing researchers.\"\"\" try: with open(filename, \"r\") as file: data = json.load(file) except FileNotFoundError:",
"file containing papers.\"\"\" try: with open(filename, \"r\") as ... |
[
"addresses.cidr_db.first_address() assert address <= addresses.cidr_db.last_address() addresses.cidr_db.reload() assert addresses.cidr_db.get_address_for_host('test_test_foo') == address assert addresses.cidr_db.has('test_test_foo') addresses.cidr_db.forget('test_test_foo')",
"Copyright (c) 2017 SiteWare Corp. Al... |
[
"'bert-base-uncased' } # See https://texar.readthedocs.io/en/latest/code/modules.html#texar.tf.modules.BERTEncoder.default_hparams bert_encoder = {} # From https://github.com/asyml/texar/blob/413e07f859acbbee979f274b52942edd57b335c1/examples/transformer/config_model.py#L27-L45 # with",
"rate, specified by 'static... |
[
"09:04 from django.db import migrations, models class Migration(migrations.Migration): dependencies = [ ('wishes', '0004_auto_20201029_0857'),",
"2020-10-29 09:04 from django.db import migrations, models class Migration(migrations.Migration): dependencies = [ ('wishes',",
"import migrations, models class Migrat... |
[
"bands and Temperature in Kelvin for Thermal bands Save: Boolean value that indicates",
"Lbands \"\"\" OutList=[] #These lists will be used to parse the meta data",
"=2*math.pi*float(jday)/DIY dSun2 = (1.00011 + 0.034221*math.cos(theta) + 0.001280*math.sin(theta) + 0.000719*math.cos(2*theta)+ 0.000077*math.sin(... |
[
"Firefox/34.0'} try: r=requests.get(urly,headers=headers) except Exception,e: print e self.results = r.content self.totalresults += self.results",
"= myparser.parser(self.totalresults, self.word) return rawres.people_twitter() def process(self): while (self.counter < self.limit): self.do_search() self.counter",
... |
[
"import json access_token = \"<KEY>\" api_url = \"https://api.instagram.com/v1\" nn_lat = 56.296504 nn_lng =",
"def request(endpoint, req_params = \"\"): req = api_url + endpoint + \"?access_token=\" +",
"+ access_token + \"&\" + req_params print(req) raw_response = urllib.request.urlopen(req).read() return jso... |
[
"valid, invalid) def test_password_rules_lower(subtests): validator = password_rules(length=6, upper=None, lower=3, numeric=None, special=None) valid =",
"def __init__(self, data=None, errors=(), raw_data=None): self.data = data self.errors = list(errors) self.raw_data =",
"field.\"\"\" def __init__(self, data=... |
[
"without raising a warning in case of NaNs in the dataset \"\"\" with",
"return True def nanmeanw(arr, axis=None): \"\"\" Computes nanmean without raising a warning in",
"in the same positions. \"\"\" if len(arrays) == 0: return True for arr",
"Computes nanmean without raising a warning in case of NaNs in the... |
[
"<gh_stars>1-10 \"\"\"Unit tests of authorization searches.\"\"\" import pytest from ..utilities.general import is_never_authz, is_no_authz,",
"# From test_templates/resource.py::ResourceSearch::init_template request.cls.search = request.cls.catalog.get_vault_search() @pytest.mark.usefixtures(\"vault_search_class... |
[
"import autofile def read_flux(ts_save_path, vrc_locs=(0,)): \"\"\" Read the geometry from the filesys \"\"\"",
"Read the geometry from the filesys \"\"\" vrc_fs = autofile.fs.vrctst(ts_save_path) if vrc_fs[-1].file.flux.exists(vrc_locs): flux_str",
"vrc_fs = autofile.fs.vrctst(ts_save_path) if vrc_fs[-1].file.... |
[
"self.trees[i].fit(X_sub, y_sub) def predict(self, X): all_preds = np.empty((X.shape[0], self.n_estimators)) for i, tree in",
"== 'entropy': self.is_classification_forest = True elif self.criterion == 'mse' or self.criterion == 'mae':",
"[] for i in range(self.n_estimators): self.trees.append(DecisionTree(max_d... |
[
"except AttributeError: print(\"SKIP\") raise SystemExit print(next(g)) print(next(g)) g.pend_throw(ValueError()) v = None try: v",
"gen(): i = 0 while 1: yield i i += 1 g =",
"# as it's legal to .throw() into it. g = gen() g.pend_throw(ValueError()) try:",
"g.pend_throw except AttributeError: print(\"SKIP\")... |
[
"the space occupied by unit Position: location of unit Orientation: as the name",
"= self.Orientation Duplicate.Attack = self.Attack Duplicate.RemainingLifetime = self.RemainingLifetime return Duplicate def __deepcopy__(self, memo):",
"memo): Default = None Exists = memo.get(self, Default) if Exists is not Defa... |
[
"from car import * def compare(car1,car2): print(car1) print(car2) car1 = Car(\"Nissan\",\"Tiida\",450000) car2 =",
"* def compare(car1,car2): print(car1) print(car2) car1 = Car(\"Nissan\",\"Tiida\",450000) car2 = Car(\"Toyota\",\"Vios\",400000) car3 =",
"compare(car1,car2): print(car1) print(car2) car1 = Car(\... |
[
"def __iter__(self): yield self.__val def __repr__(self): return \"Just({})\".format(self.__val) @singleton class Nothing(Maybe): def __rshift__(self,",
"self.__val def __repr__(self): return \"Just({})\".format(self.__val) @singleton class Nothing(Maybe): def __rshift__(self, f): return self",
"val): self.__va... |
[
"CvBridge() self.image_sub = rospy.Subscriber(\"/bebop/image_raw\",Image,self.callback) def callback(self,data): try: cv_image = self.bridge.imgmsg_to_cv2(data, \"bgr8\") except CvBridgeError",
"cv2.imshow(\"hola\", cv_image) cv2.waitKey(3) def main(args): while True: ic = image_converter() rospy.init_node('image... |
[
"Food-X Technologies # # This file is part of foodx_devops_tools. # # You",
"Copyright (c) 2021 Food-X Technologies # # This file is part of foodx_devops_tools.",
"a copy of the MIT License along with # foodx_devops_tools. If not, see",
"file is part of foodx_devops_tools. # # You should have received a copy"... |
[
"IMPORTS }.................... #!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! # WARNING: To avoid polluting the public module namespace, external",
"this is probably actually useless. # #Nonetheless, the idea itself is trivial. We",
"#* Each __class_getitem__() dunder method of ... |