Secure your code as it's written. Use Snyk Code to scan source code in minutes - no build needed - and fix issues immediately.
"""
root = Node(name="Root", geometry=Sphere(radius=10.0))
a = Node(name="A", parent=root, geometry=Sphere(radius=1.0))
a.translate((5.0, 0.0, 0.0))
scene = Scene(root)
tracer = PhotonTracer(scene)
position = (-2.0, 0.0, 0.0)
direction = (1.0, 0.0, 0.0)
initial_ray = Ray(
position=position, direction=direction, wavelength=555.0, is_alive=True
)
expected_history = [
initial_ray, # Starting ray
replace(initial_ray, position=(4.0, 0.0, 0.0)), # First intersection
replace(initial_ray, position=(6.0, 0.0, 0.0)), # Second intersection
replace(initial_ray, position=(10.0, 0.0, 0.0), is_alive=False), # Exit ray
]
history = tracer.follow(initial_ray)
for pair in zip(history, expected_history):
assert pair[0] == pair[1]
def pin_memory(batch):
"""
This is ripped off from dataloader. The only difference is that it preserves
the type of Mapping so that the OrderedDict is maintained.
"""
if isinstance(batch, torch.Tensor):
return batch.pin_memory().cuda(non_blocking=True)
elif isinstance(batch, string_classes):
return batch
elif dataclasses.is_dataclass(batch):
return dataclasses.replace(
batch,
**{
field.name: pin_memory(getattr(batch, field.name))
for field in dataclasses.fields(batch)
}
)
elif isinstance(batch, collections.Mapping):
# NB: preserving OrderedDict
return type(batch)((k, pin_memory(sample)) for k, sample in batch.items())
elif isinstance(batch, NamedTuple) or hasattr(batch, "_asdict"):
# This is mainly for WorkerDone
return type(batch)(
**{name: pin_memory(value) for name, value in batch._asdict().items()}
)
elif isinstance(batch, collections.Sequence):
return [pin_memory(sample) for sample in batch]
def transform(self, ray: Ray, context: dict) -> Ray:
_check_required_keys(set(["normal"]), context)
normal = context["normal"]
# check for angle > 90
if np.dot(normal, ray.direction) < 0.0:
normal = flip(normal)
distance = 2*EPS_ZERO
new_position = np.array(ray.position) + distance * np.array(normal)
new_ray = replace(ray, position=new_position)
return new_ray
def query_data(self, query: FredQuery, dataset_id: str, asset_id_type: str = None) -> pd.Series:
"""
Query data given a valid FRED series id and url. Will raise an HTTPError if the response was an HTTP error.
:param query: A url string of the requested data
:param id: A FRED series id
:return: with id as key and requested DataFrame as value.
"""
request = replace(query, api_key=self.api_key, series_id=dataset_id)
response = handle_proxy(self.root_url, asdict(request))
handled = self.__handle_response(response)
handled.name = dataset_id
return handled
def get_constraints(
t: Type[VT], *, nullable: bool = False, name: str = None, cls: Type = None
) -> ConstraintsT:
while should_unwrap(t):
nullable = nullable or isoptionaltype(t)
t = get_args(t)[0]
if isconstrained(t):
c: ConstraintsT = t.__constraints__ # type: ignore
if (c.name, c.nullable) != (name, nullable):
return dataclasses.replace(c, name=name, nullable=nullable)
return c
if issubclass(t, enum.Enum):
return _from_enum_type(t, nullable=nullable, name=name) # type: ignore
if isnamedtuple(t) or istypeddict(t):
handler = _from_class
else:
handler = _CONSTRAINT_BUILDER_HANDLERS.get_by_parent(origin(t), _from_class) # type: ignore
c = handler(t, nullable=nullable, name=name, cls=cls) # type: ignore
return c
def child(self, child_name: str, path: Tuple[int, ...]) -> 'Address':
"""Return a new child of the current Address.
Args:
child_name (str): The name of the child node.
This address' name is appended to ``parent``.
Returns:
~.Address: The new address object.
"""
return dataclasses.replace(
self,
module_path=self.module_path + path,
name=child_name,
parent=self.parent + (self.name,) if self.name else self.parent,
)
def transform(self, func: Callable[[Expression], Expression]) -> Expression:
"""
Transforms the subtree starting from the children and then applying
the transformation function to the root.
This order is chosen to make the semantics of transform more meaningful,
the transform operation will be performed on the children first (think
about the parameters of a function call) and then to the node itself.
The consequence of this is that, if the transformation function replaces
the root with something else, with different children, we trust the
transformation function and we do not run that same function over the
new children.
"""
transformed = replace(
self,
parameters=tuple(map(lambda child: child.transform(func), self.parameters)),
)
return func(transformed)
def _create(
session: Session,
dataset: Dataset,
*,
name: str,
is_nullable: bool,
type: AttributeType = attribute_type.DEFAULT,
description: Optional[str] = None,
) -> Attribute:
"""Same as `tc.attribute.create`, but does not check for reserved attribute
names.
"""
attrs_url = replace(dataset.url, path=dataset.url.path + "/attributes")
url = replace(attrs_url, path=attrs_url.path + f"/{name}")
body = {
"name": name,
"type": attribute_type.to_json(type),
"isNullable": is_nullable,
}
if description is not None:
body["description"] = description
r = session.post(str(attrs_url), json=body)
if r.status_code == 409:
raise AlreadyExists(str(url))
data = response.successful(r).json()
return _from_json(url, data)
#training baseline Bangla model CNN+LSTM
C4 = Config(experiment_name = 'Bangla_Baseline_Test', exp_dir = 'Experiments', train_data = '/content/drive/My Drive/data/training', valid_data = '/content/drive/My Drive/data/validation', langs = ['arab'], pli = [1000], mode = ['train'])
C4_val = replace(C4,mode='val')
C2 = replace(C1, experiment_name = 'TestDataclass1', langs = ['hin','ban','arab'], pli = [1000,1000,1000], mode = ['train','train','train'])
C3_test = replace(C2, experiment_name = 'ABH(CNN)', pli = [2,2,2], share = 'CNN', total_data_usage_ratio = '0.05')
C3_tst_val = replace(C3_test, mode = ['val','val','val'])
'''
C_subnet_ban = Config(experiment_name = 'Gen_Ban_Subnet1', exp_dir='Experiments', train_data = 'training', valid_data = 'validation', langs = ['ban'], pli = [1000], mode=['train'], num_iter = 100, task_id = [1])
C_subnet_ban_val = replace(C_subnet_ban,mode=['val'])
P_subnet_ban = PruneConfig()
C_subnet_ban = Config(experiment_name = 'Gen_Ban_Subnet', exp_dir='Experiments', train_data = '/content/drive/My Drive/data/training', valid_data = '/content/drive/My Drive/data/validation', langs = ['ban'], pli = [1000], mode=['train'], num_iter = 6000, task_id = [1])
C_subnet_ban_val = replace(C_subnet_ban,mode=['val'])
C_subnet_arab = Config(experiment_name = 'Gen_Arab_Subnet', exp_dir='Experiments', train_data = '/content/drive/My Drive/data/training', valid_data = '/content/drive/My Drive/data/validation', langs = ['arab'], pli = [1000], mode=['train'], num_iter = 6000, task_id = [0])
C_subnet_arab_val = replace(C_subnet_arab,mode=['val'])
C_subnet_hin = Config(experiment_name = 'Gen_Hin_Subnet', exp_dir='Experiments', train_data = '/content/drive/My Drive/data/training', valid_data = '/content/drive/My Drive/data/validation', langs = ['hin'], pli = [1000], mode=['train'], num_iter = 6000, task_id = [2])
P_subnet_ban = PruneConfig()
def _analyze_ambiguous_record(ambiguous_record: AmbiguousRecord, charge_ids_with_question: List[str]):
charge_id_to_time_eligibilities = []
ambiguous_record_with_errors = []
for record in ambiguous_record:
charge_id_to_time_eligibility = Expunger.run(record)
charge_id_to_time_eligibilities.append(charge_id_to_time_eligibility)
ambiguous_record_with_errors.append(record)
record = RecordMerger.merge(
ambiguous_record_with_errors, charge_id_to_time_eligibilities, charge_ids_with_question
)
sorted_record = RecordCreator.sort_record(record)
return replace(sorted_record, errors=tuple(ErrorChecker.check(sorted_record)))