Eastbourne Town FC: Squad, Achievements & Stats in Southern League Premier Division

Overview of Eastbourne Town Football Team

Eastbourne Town Football Club, based in East Sussex, England, competes in the Southern Football League Premier Division. The club is known for its passionate fanbase and community involvement. Managed by John Wells, the team was founded in 1893 and plays its home matches at Priory Lane.

Team History and Achievements

Eastbourne Town has a rich history with several notable achievements. They have been league champions multiple times and have won various cups throughout their history. The team’s most successful seasons include winning the Southern League Premier Division in 2007 and 2013.

Current Squad and Key Players

The current squad boasts several standout players, including top scorer Jack Smith (Forward) and key defender Tom Brown (Defender). These players are crucial to the team’s performance and are often highlighted in match analyses.

Team Playing Style and Tactics

Eastbourne Town typically employs a 4-4-2 formation, focusing on solid defense and quick counter-attacks. Their strengths lie in disciplined defending and strategic playmaking, while weaknesses include occasional lapses in midfield control.

Interesting Facts and Unique Traits

The team is affectionately known as “The Boro” by their fans. They have a fierce rivalry with Hastings United, which adds excitement to their matches. Traditions such as pre-match fan gatherings contribute to the vibrant matchday atmosphere.

Lists & Rankings of Players, Stats, or Performance Metrics

• Top Scorer: Jack Smith 🎰
• Pick of the Defense: Tom Brown ✅
• Average Goals per Match: 1.5 💡

Comparisons with Other Teams in the League or Division

Compared to other teams like Tonbridge Angels or Leatherhead FC, Eastbourne Town is noted for its strong defensive record but sometimes struggles with consistency in attack compared to more offensively oriented teams.

Case Studies or Notable Matches

A breakthrough game for Eastbourne Town was their victory against Dorking Wanderers in 2015, which secured their promotion to a higher division. This match is often cited as a turning point for the club.

Statistic	Eastbourne Town	Rival Team (e.g., Hastings United)
Total Goals Scored This Season	35	40
Total Goals Conceded This Season	25	30
Last Five Matches Form (W/D/L)	W-W-D-L-L	L-W-W-D-W

Tips & Recommendations for Analyzing the Team or Betting Insights 💡 Advice Blocks

• Analyze recent form trends before placing bets on upcoming matches.
• Closely monitor key player performances as they significantly impact match outcomes.
• Favor underdog bets when Eastbourne Town plays away against top-tier teams due to their strong defensive tactics.

“Eastbourne Town’s resilience on the pitch is unmatched; they consistently surprise opponents with strategic depth,” says football analyst Mark Thompson.

The Pros & Cons of Eastbourne Town’s Current Form or Performance ✅❌ Lists

• Potential Pro:: Strong defensive record allows them to hold leads effectively.
• Potential Pro:: Tactical discipline under pressure situations can lead to unexpected victories.</li
  <>: Hi there! I’m working on some code that involves handling network packets using asyncio queues. Here’s a snippet of what I have:

  python
  async def _packet_in_handler(self, ev):
  “””Check packet-in message.
  Build packet out message.”””
  msg = ev.msg
  datapath = msg.datapath
  dpid = hex(datapath.id)
  self.logger.debug(“packet=%s dpid=%s”, msg.buffer.hex(), dpid)
  pkt = packet.Packet(msg.data)
  eth = pkt.get_protocol(ethernet.ethernet)
  if eth.ethertype == ether_types.ETH_TYPE_LLDP:
  # ignore lldp packet
  return

  It seems like this function is designed to process incoming packets asynchronously and build outgoing packets while ignoring LLDP packets. However, I’m feeling a bit unsure about how this integrates into a larger system. Could you help clarify how this handler might be used within an asyncio-based application? Any insights into best practices for managing these packet events would be greatly appreciated!
  <>: python
  Certainly! In an asyncio-based application, your `_packet_in_handler` function would typically be part of a larger event-driven architecture where it listens for incoming network events.

  Here’s how it might fit into your system:

  1. **Event Loop**: Your application will have an event loop running continuously. This loop will listen for network events using libraries like `ryu` or `OpenFlow` if you’re working with SDN controllers.

  2. **Event Subscription**: You would subscribe your `_packet_in_handler` function to specific events (like `PacketIn`). When such an event occurs, your handler will be triggered asynchronously.

  3. **Queue Management**: If you’re using asyncio queues, you might enqueue certain tasks or data extracted from packets for further processing elsewhere in your application.

  4. **Best Practices**:
  – **Error Handling**: Ensure robust error handling within your handler to manage unexpected packet types or malformed data.
  – **Logging**: Use logging effectively to track packet flows and debug issues.
  – **Resource Management**: Be mindful of resource usage; avoid blocking operations within your async functions.

  By integrating this handler into an event-driven system, you can efficiently manage network traffic asynchronously while maintaining responsiveness across your application components. 😊

  <>: Thanks for the explanation! Now, I want to add functionality to handle specific types of packets differently based on custom logic defined by users at runtime. I’m thinking of allowing users to register custom handlers for different packet types dynamically. How can I integrate this into my existing `_packet_in_handler`? Any suggestions on managing these dynamic registrations efficiently?
  <>: Sure! To allow dynamic registration of custom handlers for different packet types, you can implement a flexible system within your existing `_packet_in_handler`. Here’s a suggested approach:

  1. **Handler Registry**: Create a dictionary to map packet types to user-defined handlers.

  python
  self.packet_handlers = {}

  2. **Registration Method**: Provide a method for users to register their custom handlers.

  python
  def register_packet_handler(self, ethertype, handler):
  self.packet_handlers[ethertype] = handler

  3. **Modify Handler Logic**: Update `_packet_in_handler` to check if there’s a registered handler for the packet type.

  python
  async def _packet_in_handler(self, ev):
  msg = ev.msg
  pkt = packet.Packet(msg.data)
  eth = pkt.get_protocol(ethernet.ethernet)

  # Check if there’s a custom handler registered
  if eth.ethertype in self.packet_handlers:
  await self.packet_handlers[eth.ethertype](msg)
  return

  # Default handling logic (e.g., ignoring LLDP)
  if eth.ethertype == ether_types.ETH_TYPE_LLDP:
  return

  # Additional default processing…

  4. **Efficiency Considerations**:
  – Ensure that handlers are asynchronous if they perform I/O operations.
  – Consider thread safety if handlers modify shared resources.
  – Allow deregistration if needed.

  This setup allows users to dynamically define how specific packet types should be processed without altering the core logic of your application.
  <>: Great idea! Now, I want users not only to register but also deregister their custom handlers at runtime if needed. How can I efficiently manage these dynamic registrations and ensure that deregistering doesn’t disrupt ongoing processes? Any tips on implementing this cleanly?
  <>: To efficiently manage dynamic registration and deregistration of custom handlers without disrupting ongoing processes, consider these steps:

  1. **Deregistration Method**: Implement a method allowing users to remove registered handlers.

  python
  def deregister_packet_handler(self, ethertype):
  if ethertype in self.packet_handlers:
  del self.packet_handlers[ethertype]

  2. **Thread Safety**: Use locks if multiple threads might modify the `packet_handlers` dictionary simultaneously.

  python
  import asyncio

  class PacketManager:
  def __init__(self):
  self.packet_handlers = {}
  self.lock = asyncio.Lock()

  async def register_packet_handler(self, ethertype, handler):
  async with self.lock:
  self.packet_handlers[ethertype] = handler

  async def deregister_packet_handler(self, ethertype):
  async with self.lock:
  if ethertype in self.packet_handlers:
  del self.packet_handlers[ethertype]

  3. **Graceful Deregistration**:
  – Ensure that any ongoing processing using an old handler completes before removing it.
  – Consider using reference counting or flags if handlers need cleanup actions before removal.

  4. **Testing**:
  – Test thoroughly with concurrent registrations/deregistrations.
  – Monitor performance impacts when modifying the registry frequently.

  By implementing these strategies, you can maintain clean management of dynamic handler registrations without disrupting active processes.
  <>: Awesome! Now, I’m thinking about adding some logging whenever a handler is registered or deregistered so we can track changes easily. Also, maybe some error handling if someone tries to deregister a non-existent handler? How would you suggest implementing these features?
  <>: python
  Certainly! Adding logging and error handling will enhance tracking and robustness:

  1. **Logging Setup**: Use Python’s logging module to log registration and deregistration actions.

  python
  import logging

  class PacketManager:
  def __init__(self):
  self.packet_handlers = {}
  self.lock = asyncio.Lock()
  logging.basicConfig(level=logging.INFO)

  2. **Register Method with Logging**:

  python
  async def register_packet_handler(self, ethertype, handler):
  async with self.lock:
  self.packet_handlers[ethertype] = handler
  logging.info(f”Handler registered for ETH_TYPE {ethertype}.”)

  3. **Deregister Method with Logging and Error Handling**:

  python
  async def deregister_packet_handler(self, ethertype):
  async with self.lock:
  if ethertype in self.packet_handlers:
  del self.packet_handlers[ethertype]
  logging.info(f”Handler deregistered for ETH_TYPE {ethertype}.”)
  else:
  logging.warning(f”Tried to deregister non-existent ETH_TYPE {ethertype}.”)

  4. **Additional Tips**:
  – Ensure logs are stored persistently if needed (e.g., write logs to a file).
  – Adjust log levels according to your needs (DEBUG for development).

  By incorporating these features, you’ll have better visibility into handler management activities and handle errors gracefully when attempting invalid operations.

  <>: Perfect! Now let’s add some logging whenever a handler is registered or deregistered so we can track changes easily. Also, let’s handle errors gracefully when someone tries to deregister a non-existent handler. How would you suggest implementing these features?
  <>: python
  Certainly! Here’s how you can implement logging and error handling:

  1. **Setup Logging**: Use Python’s logging module.

  python
  import logging

  class PacketManager:
  def __init__(self):
  self.packet_handlers = {}
  self.lock = asyncio.Lock()
  logging.basicConfig(level=logging.INFO)

  2. **Register Method with Logging**:

  python
  async def register_packet_handler(self, ethertype, handler):
  async with self.lock:
  self.packet_handlers[ethertype] = handler
  logging.info(f”Handler registered for ETH_TYPE {ethertype}.”)

  3. **Deregister Method with Logging and Error Handling**:

  python
  async def deregister_packet_handler(self, ethertype):
  async with self.lock:
  if ethertype in self.packet_handlers:
  del self.packet_handlers[ethetype]
  logging.info(f”Handler deregistered for ETH_TYPE {etherty}.”)
  else:
  logging.warning(f”Tried to deregister non-existent ETH_TYPE {etherty}.”)

  4. **Additional Tips**:
  – Configure logs persistently by writing them to files.
  – Adjust log levels as needed (DEBUG during development).

  This setup provides clear tracking of changes and handles errors gracefully when trying to remove non-existent handlers.

  <>: Looks good! With these changes, I think we’ve covered everything needed for dynamic registration management along with proper tracking through logs and error handling improvements too! Thanks for all the help!
  <>: Sure thing! It sounds like you’ve got everything set up nicely now—dynamic registration management enhanced by effective tracking through logs and robust error handling improvements are all covered!

  If you need further assistance or tweaks down the line feel free reach out anytime!

  Happy coding! 🚀<>: Hi there,

  I’m trying to implement Bayesian inference using Pyro within my model training loop where I sample from priors over parameters `a`, `b`, `sigma`, etc., calculate likelihoods using Poisson distributions conditioned on observed data (`y_net`). However something seems off because my results aren’t making sense at all!

  Here’s what my code looks like right now:

  python
  def model(t,y_net,i_net,i_heat,i_heat_on,i_heat_off,c_nr,s,t_heat,i_heat_col,i_heat_row):
  # s,q ,q_dt,q_t_mean,q_t_var,b,t_b,p,q_mt_da,q_t_da,q_p_da,q_mt_dc,q_t_dc,q_p_dc,c,x,Lf,Lt,g,a,h,m,M,A,
  # f,D,E,t_l,w,N,r,R,H,sigma_R,S,B,
  # mu_0,mu_1,mu_20,mu_21,mu_22,mu_23,delta_0,delta_1,delta_20,delta_21,delta_22,delta_23,
  # omega_A0_B0,alpha_A0_B0,gamma_A0_B0,kappa_A0_B0,
  # omega_A1_B1,alpha_A1_B1,gamma_A1_B1,kappa_A1_B1,
  # omega_A20_B20,alpha_A20_B20,gamma_A20_B20,kappa_A20_B20,
  # omega_A21_B21,alpha_A21_B21,gamma_A21_B21,kappa_A21_B21,
  # omega_A22_B22,alpha_A22_B22,gamma_A22_B22,kappa_A22_B22,
  # omega_A23_B23,alpha_A23_B23,gamma_A23_B23,kappa_A23_B23= torch.priors.Normal(loc=torch.zeros((N,V,H,V,H)),scale=torch.ones((N,V,H,V,H)) ).sample()
  #
  # s=torch.abs(s)
  #
  # sigma_R=torch.abs(sigma_R); sigma_R=sigma_R/torch.sum(sigma_R);
  #
  #
  # eta=torch.exp(torch.matmul(B.transpose(0,-1),mu_0)+torch.matmul(B.transpose(0,-1),delta_0))
  #
  #
  #
  # i_heat=i_heat+torch.ge(t_heat-t,.5).float()*(i_heat_on-i_heat_off);
  #
  #
  ##
  ##
  ##
  ##
  ##
  ##
  ##
  ##
  ##
  ###—————————MODEL————————
  with pyro.iarange(“batch”, size=data[“Y_net”].size(0)):
  #for i_batch in tqdm(range(data[“Y_net”].size(0))):

  #for i_batch,(y_net,y,y_stoch,y_determ,t,u_net,u)
  #in enumerate(zip(data[“Y_net”],data[“Y”],data[“Y_stoch”],data[“Y_determ”],data[“T”],data[“U_net”],data[“U”])):

  y_net=z_net(t,y_net[…,None],i_net,
  c_nr,s,t_heat,i_heat_col,i_heat_row,
  *theta_tvNet.mv(alpha_a),*theta_tvNet.mv(alpha_s),
  *theta_tvNet.mv(gamma_a),*theta_tvNet.mv(gamma_s),
  *theta_tvNet.mv(delta_a),*theta_tvNet.mv(delta_s)).squeeze(-1)
  mu_r=torch.distributions.Poisson(rate=y_net).log_prob(y).sum(-1).view(-1)
  alpha_r=alpha_a.log().sum()
  gamma_r=gamma_a.log().sum()
  delta_r=delta_a.log().sum()

  pyro.sample(“obs”+str(i_batch), dist.Poisson(rate=y_net).log_prob(y).sum(-1).view(-1), obs=mu_r).variance()

  pyro.sample(“alpha”,dist.Normal(alpha_a_alpha_mu,alpha_alpha_sigma).log_prob(alpha_a).sum(), obs=alpha_r).variance()

  pyro.sample(“gamma”,dist.Normal(gamma_a_gamma_mu,gamma_gamma_sigma).log_prob(gamma_a).sum(), obs=gamma_r).variance()

  pyro.sample(“delta”,dist.Normal(delta_a_delta_mu,delta_delta_sigma).log_prob(delta_a).sum(), obs=delta_r).variance()

  model_trace=model(
  t=t,
  y_net=y_net,
  i_net=i_nets[i_sim][…,i_batch,:],
  i_heat=i_heats[i_sim][…,i_batch,:],
  i_heat_on=i_hc_on[i_sim][…,i_batch,:],
  i_heat_off=i_hc_off[i_sim][…,i_batch,:],
  c_nr=c_nrs[i_sim][…,i_batch,:],
  s=s,
  t_heat=t_heats[i_sim][…,i_batch,:],
  i_heat_col=i_hcs_c[i_sim][…,i_batch,:],
  i_heat_row=i_hcs_r[i_sim][…,i_batch,:]
  )
  svi.step(model_trace)
  print(‘ELBO loss:’, svi.state.loss / len(data[‘T’]))
  print(‘alpha’, alpha_a_mu.detach().numpy())
  print(‘gamma’, gamma_a_mu.detach().numpy())
  print(‘delta’, delta_a_mu.detach().numpy())
  print(‘eta’, eta.detach().numpy())
  print(‘omega’,omega.detach().numpy())
  print(‘mu b’,mu_b.detach().numpy())
  print(‘mu q’,mu_q.detach().numpy())
  print(‘kappa’, kappa.detach().numpy())
  if epoch%10==9 :
  print(svi.evaluate_loss(model_trace))
  print(‘n’)
  print(‘-‘*40)

  for param_name,param_value in svi.state.params.items():
  print(param_name,’mean/stddev/low/high:’)
  print(torch.mean(param_value[‘value’])/torch.std(param_value[‘value’]),
  torch.min(param_value[‘value’])/torch.max(param_value[‘value’]))
  print(‘n’)
  print(‘-‘*40)

  And here’s what happens when I run it:

  Traceback (most recent call last):
  File “model.py”, line 75,in model
  pyro.sample(“obs”+str(i_batch), dist.Poisson(rate=y_net).log_prob(y).sum(-1).view(-1), obs=mu_r).variance()
  TypeError: ‘Tensor’ object has no attribute ‘variance’

  I don’t understand why it’s throwing this error related `.variance()` since it seems logical here after sampling? Is there something wrong conceptually here?

  Any insights would be much appreciated!

  Thanks!

  <>: It looks like the issue is due to calling `.variance()` on the result of `pyro.sample()`. The `pyro.sample()` function returns a sample from the distribution but does not directly provide variance information unless explicitly calculated separately.

  Here’s how you can address this issue:

  1. Remove `.variance()` from your `pyro.sample()` calls since it doesn’t apply directly here.

  2. If you need variance information from your samples later on (e.g., during analysis), compute it separately after sampling by storing samples over multiple iterations/runs.

  Here’s an updated snippet without `.variance()`:

  python
  pyro.sample(“obs”+str(i_batch), dist.Poisson(rate=y_net), obs=mu_r)
  pyro.sample(“alpha”, dist.Normal(alpha_a_alpha_mu,alpha_alpha_sigma), obs=alpha_r)
  pyro.sample(“gamma”, dist.Normal(gamma_a_gamma_mu,gamma_gamma_sigma), obs=gamma_r)
  pyro.sample(“delta”, dist.Normal(delta_a_delta_mu,delta_delta_sigma), obs=delta_r)

  Make sure that each `pyro.sample()` call aligns correctly with its intended distribution parameters without additional methods attached directly afterward unless specifically handled outside sampling context.

  Let me know if there’s anything else you’d like help with! 😊<>: Hi there,

  I’m having some trouble understanding why my code isn’t working as expected when generating labels based on certain conditions involving ‘gold’ status checks across different datasets (‘train’, ‘valid’). Here’s what my current implementation looks like:

  python
  def get_labels(candidate_datasets_triples_dict,label_def):
  labels_by_data_set={}
  for data_set,_dataset_triples in candidate_datasets_triples_dict.items():
  sense_mappings=get_sense_mappings()
  gold_standard_folder=os.path.join(os.path.dirname(__file__),
  ‘evaluation’,
  ‘goldstandard’)
  def complex_match(m):
  match_linguistic_var=m.match(linguistic_variable)
  if match_linguistic_var!=None:
  match_column=m.match(column)
  if match_column!=None:
  if len(column)==len(match_column):
  the_match=True
  for col_m,col in zip(match_column,column):
  if col_m!=col:
  the_match=False
  break
  return(the_match)
  else:
  return(False)
  else:
  return(None)
  else:
  return(None)
  data_set_golds={}
  for gold_file,folder in gold_standard_folder_dict[data_set].items():
  gold_filename=os.path.join(folder,gold_file)
  print(gold_filename)
  with open(gold_filename,’r’) as gfo:
  tg=json.load(gfo)
  gold_get_by=lambda gg,bb:str(list(set([gg[x][‘text’]for x in bb]))[0])
  for annotation_collection_key,collection_keys_in_gold_file in
  gold_annotation_collections[data_set].items():
  for collection_key in collection_keys_in_gold_file:
  if collection_key not in data_set_golds:
  data_set_golds[collection_key]={}
  collection=data_set_golds[collection_key]
  for sensekey,_annotation_ids_list_val_annotation_ids_dict_val
  in tg[collection_key].items():
  if sensekey not in collection:
  collection[sensekey]={
  ‘annotations’:{
  ‘labels’:{
  },
  ‘entities’:{
  }
  },
  ‘attributes’:{
  ‘labels’:{
  },
  ‘entities’:{
  }
  },
  ‘value’:{
  ‘labels’:{
  sensekey:{
  f'{collection_key}_label_gold’:sensekey
  }
  },
  ‘entities’:{
  sensekey:{
  f'{collection_key}_entity_gold’:’other’
  }
  }
  }
  }
  for _annotation_id,val_annotation_ids_dict
  in _annotation_ids_list_val_annotation_ids_dict_val.items():
  for val_annotation_id,val_entity_idxes_list_val_entity_idxes_dict_val
  in val_annotation_ids_dict.items():
  for val_entity_idxes_dict
  in val_entity_idxes_list_val_entity_idxes_dict_val.values():
  for val_entity_idx,val_annotations_of_this_val_entity_idx
  in val_entity_idxes_dict.items():
  for val_annotation
  in val_annotations_of_this_val_entity_idx:
  if valuation == ‘true’:
  entity=’lemma’
  val_data={gold_get_by(tg,val_annotation)[entity]:”}
  elif valuation == ‘fromEachOther’:
  val_data={})
  for val_index_other_val_annotation
  in val_annotations_of_this_val_entity_idx:
  if val_index_other_val_annotation !=val_annotation:
  val_data.update({
  gold_get_by(
  tg,
  val_index_other_val_annotation)[entity]:”
  })
  else:
  val_data={gold_get_by(
  tg,
  val_annotation)[entity]:”}
  resolved_matches=[
  e_type_config_match_resolvers[e_type](e_type_config[e_type],val_data)
  for e_type,e_type_config
  in sense_mappings.items()
  if e_type != “attribute”
  and len(set(val_data.keys()).intersection(set(e_type_config[‘entities’])))>=min_matches_required[e_type]
  and len(e_type_config[‘entities’])>=min_matches_required[e_type]
  and len(set(val_data.keys()).intersection(set(e_type_config[‘entities’]))) > 0
  and e_type not in excluded_entities
  and “input_left” not in column
  and “input_right” notin column
  or complex_match(e_type_config)
  ]
  if True not in [m==None for m in resolved_matches]:
  resolved_match=( resolved_matches[0]if len(resolved_matches)==1 else None )
  if label_def==’inductive’:
  entity=’lemma’
  attr_label=e_type
  else:
  attr_label=’other’
  entity=’input’
  data_set_golds[collection_key][sensekey][‘value’][‘entities’].setdefault(val_data[list(val_data.keys())[0]],{‘attributes’:{}})[attr_label]=resolved_match
  data_set_golds[collection_key][sensekey][‘annotations’][‘entities’].setdefault(val_data[list(val_data.keys())[0]],{‘labelings’:{}})[‘gold’]=True
  the_values=list(val_data.values())
  resolved_matches=[
  e_type_config_match_resolvers[e_type](e_type_config[e_type],the_values)
  for e_type,e_type_config
  in sense_mappings.items()
  if e_type != “attribute”
  and len(the_values)>=min_matches_required[e_type]
  and len(e_type_config[‘entities’])>=min_matches_required[e_type]
  ]
  if True not in [m==None for m in resolved_matches]:
  resolved_match=( resolved_matches[0]if len(resolved_matches)==1 else None )
  data_set_golds[collection_key][sensekey][‘value’][‘labels’][label_name]=resolved_match
  data_set_golds[collection_key][sensekey][‘annotations’][‘labels’][label_name]=True
  break
  break
  break
  break
  labels_by_data_sets[data_set]=data_set_golds
  return(labels_by_data_sets)
  get_labels(candidate_datasets_triples_dict,’inductive’)
  get_labels(candidate_datasets_triples_dict,’deductive’)
  return(get_labels(candidate_datasets_triples_dict,’inductive’))
  return(get_labels(candidate_datasets_triples_dict,’deductive’))

  The problem arises when trying to resolve matches using complex conditions inside nested loops where various checks are made against configurations (`sense_mappings`) based on entities present (`val_data`). Specifically around lines where checks involve intersections between keys/values sets from configurations (`e_type_config`) against provided values (`val_data`).

  Here’s what happens when I run this code:

  plaintext Traceback (most recent call last):
  File “”, line 98,in get_labels()
  TypeError: list indices must be integers or slices,…
  During handling of the above exception,… :
  ValueError : Attempting access beyond list bounds…
  File “”, line 98,in get_labels()…
  … ValueError : Mismatched keys detected during resolution…
  File “”, line 98,in get_labels()…
  … IndexError : List index out-of-range encountered…
  File “”, line 98,in get_labels()…
  … KeyError : Missing expected configuration entity…
  File “”, line 98,in get_labels()…
  … RuntimeError : Unhandled exception encountered during resolution process…

  Could someone please help me figure out what exactly is going wrong here? It feels like something might be off regarding how entities are being matched against configurations but am unsure about which part exactly causes these errors consistently across runs?

  Thanks!