#

import os
from casadi import *
from .utils import ALLOWED_CASADI_VERSIONS, is_empty, casadi_length, casadi_version_warning

def generate_c_code_constraint( model, con_name, is_terminal, opts ):

    casadi_version = CasadiMeta.version()

            

Reported by Pylint.

              
import os
from casadi import *
from .utils import ALLOWED_CASADI_VERSIONS, is_empty, casadi_length, casadi_version_warning

def generate_c_code_constraint( model, con_name, is_terminal, opts ):

    casadi_version = CasadiMeta.version()
    casadi_opts = dict(mex=False, casadi_int='int', casadi_real='double')

            

Reported by Pylint.

              
def generate_c_code_constraint( model, con_name, is_terminal, opts ):

    casadi_version = CasadiMeta.version()
    casadi_opts = dict(mex=False, casadi_int='int', casadi_real='double')

    if casadi_version not in (ALLOWED_CASADI_VERSIONS):
        casadi_version_warning(casadi_version)


            

Reported by Pylint.

                  x = model.x
    p = model.p

    if isinstance(x, casadi.MX):
        symbol = MX.sym
    else:
        symbol = SX.sym

    if is_terminal:

            

Reported by Pylint.

                  p = model.p

    if isinstance(x, casadi.MX):
        symbol = MX.sym
    else:
        symbol = SX.sym

    if is_terminal:
        con_h_expr = model.con_h_expr_e

            

Reported by Pylint.

                  if isinstance(x, casadi.MX):
        symbol = MX.sym
    else:
        symbol = SX.sym

    if is_terminal:
        con_h_expr = model.con_h_expr_e
        con_phi_expr = model.con_phi_expr_e
        # create dummy u, z

            

Reported by Pylint.

                          else:
                fun_name = con_name + '_constr_h_fun_jac_uxt_zt'

            jac_ux_t = transpose(jacobian(con_h_expr, vertcat(u,x)))
            jac_z_t = jacobian(con_h_expr, z)
            constraint_fun_jac_tran = Function(fun_name, [x, u, z, p], \
                    [con_h_expr, jac_ux_t, jac_z_t])

            constraint_fun_jac_tran.generate(fun_name, casadi_opts)

            

Reported by Pylint.

                          else:
                fun_name = con_name + '_constr_h_fun_jac_uxt_zt'

            jac_ux_t = transpose(jacobian(con_h_expr, vertcat(u,x)))
            jac_z_t = jacobian(con_h_expr, z)
            constraint_fun_jac_tran = Function(fun_name, [x, u, z, p], \
                    [con_h_expr, jac_ux_t, jac_z_t])

            constraint_fun_jac_tran.generate(fun_name, casadi_opts)

            

Reported by Pylint.

                          else:
                fun_name = con_name + '_constr_h_fun_jac_uxt_zt'

            jac_ux_t = transpose(jacobian(con_h_expr, vertcat(u,x)))
            jac_z_t = jacobian(con_h_expr, z)
            constraint_fun_jac_tran = Function(fun_name, [x, u, z, p], \
                    [con_h_expr, jac_ux_t, jac_z_t])

            constraint_fun_jac_tran.generate(fun_name, casadi_opts)

            

Reported by Pylint.

                              fun_name = con_name + '_constr_h_fun_jac_uxt_zt'

            jac_ux_t = transpose(jacobian(con_h_expr, vertcat(u,x)))
            jac_z_t = jacobian(con_h_expr, z)
            constraint_fun_jac_tran = Function(fun_name, [x, u, z, p], \
                    [con_h_expr, jac_ux_t, jac_z_t])

            constraint_fun_jac_tran.generate(fun_name, casadi_opts)
            if opts['generate_hess']:

            

Reported by Pylint.

              
if __name__ == '__main__':
  from multiprocessing import Process, Queue
  q: Queue[str] = Queue()
  p = Process(target=test, args=(q,))
  p.daemon = True
  p.start()

  keyboard_poll_thread(q)

            

Reported by Pylint.

                  termios.tcsetattr(STDIN_FD, termios.TCSADRAIN, old_settings)
  return ch

def keyboard_poll_thread(q: 'Queue[str]'):
  while True:
    c = getch()
    # print("got %s" % c)
    if c == '1':
      q.put("cruise_up")

            

Reported by Pylint.

                    q.put("quit")
      break

def test(q: 'Queue[str]') -> NoReturn:
  while True:
    print([q.get_nowait() for _ in range(q.qsize())] or None)
    time.sleep(0.25)

if __name__ == '__main__':

            

Reported by Pylint.

              import sys
import termios
import time
from termios import (BRKINT, CS8, CSIZE, ECHO, ICANON, ICRNL, IEXTEN, INPCK,
                     ISTRIP, IXON, PARENB, VMIN, VTIME)
from typing import NoReturn

# Indexes for termios list.
IFLAG = 0

            

Reported by Pylint.

              
STDIN_FD = sys.stdin.fileno()

def getch() -> str:
  old_settings = termios.tcgetattr(STDIN_FD)
  try:
    # set
    mode = old_settings.copy()
    mode[IFLAG] &= ~(BRKINT | ICRNL | INPCK | ISTRIP | IXON)

            

Reported by Pylint.

              STDIN_FD = sys.stdin.fileno()

def getch() -> str:
  old_settings = termios.tcgetattr(STDIN_FD)
  try:
    # set
    mode = old_settings.copy()
    mode[IFLAG] &= ~(BRKINT | ICRNL | INPCK | ISTRIP | IXON)
    #mode[OFLAG] &= ~(OPOST)

            

Reported by Pylint.

              
def getch() -> str:
  old_settings = termios.tcgetattr(STDIN_FD)
  try:
    # set
    mode = old_settings.copy()
    mode[IFLAG] &= ~(BRKINT | ICRNL | INPCK | ISTRIP | IXON)
    #mode[OFLAG] &= ~(OPOST)
    mode[CFLAG] &= ~(CSIZE | PARENB)

            

Reported by Pylint.

                old_settings = termios.tcgetattr(STDIN_FD)
  try:
    # set
    mode = old_settings.copy()
    mode[IFLAG] &= ~(BRKINT | ICRNL | INPCK | ISTRIP | IXON)
    #mode[OFLAG] &= ~(OPOST)
    mode[CFLAG] &= ~(CSIZE | PARENB)
    mode[CFLAG] |= CS8
    mode[LFLAG] &= ~(ECHO | ICANON | IEXTEN)

            

Reported by Pylint.

                try:
    # set
    mode = old_settings.copy()
    mode[IFLAG] &= ~(BRKINT | ICRNL | INPCK | ISTRIP | IXON)
    #mode[OFLAG] &= ~(OPOST)
    mode[CFLAG] &= ~(CSIZE | PARENB)
    mode[CFLAG] |= CS8
    mode[LFLAG] &= ~(ECHO | ICANON | IEXTEN)
    mode[CC][VMIN] = 1

            

Reported by Pylint.

                  mode = old_settings.copy()
    mode[IFLAG] &= ~(BRKINT | ICRNL | INPCK | ISTRIP | IXON)
    #mode[OFLAG] &= ~(OPOST)
    mode[CFLAG] &= ~(CSIZE | PARENB)
    mode[CFLAG] |= CS8
    mode[LFLAG] &= ~(ECHO | ICANON | IEXTEN)
    mode[CC][VMIN] = 1
    mode[CC][VTIME] = 0
    termios.tcsetattr(STDIN_FD, termios.TCSAFLUSH, mode)

            

Reported by Pylint.

              #!/usr/bin/env python3
from cereal import car
from common.params import Params
import cereal.messaging as messaging
from selfdrive.controls.lib.events import Events
from selfdrive.monitoring.driver_monitor import DriverStatus
from selfdrive.locationd.calibrationd import Calibration



            

Reported by Pylint.

              #!/usr/bin/env python3
from cereal import car
from common.params import Params
import cereal.messaging as messaging
from selfdrive.controls.lib.events import Events
from selfdrive.monitoring.driver_monitor import DriverStatus
from selfdrive.locationd.calibrationd import Calibration



            

Reported by Pylint.

              #!/usr/bin/env python3
from cereal import car
from common.params import Params
import cereal.messaging as messaging
from selfdrive.controls.lib.events import Events
from selfdrive.monitoring.driver_monitor import DriverStatus
from selfdrive.locationd.calibrationd import Calibration



            

Reported by Pylint.

              from cereal import car
from common.params import Params
import cereal.messaging as messaging
from selfdrive.controls.lib.events import Events
from selfdrive.monitoring.driver_monitor import DriverStatus
from selfdrive.locationd.calibrationd import Calibration


def dmonitoringd_thread(sm=None, pm=None):

            

Reported by Pylint.

              from common.params import Params
import cereal.messaging as messaging
from selfdrive.controls.lib.events import Events
from selfdrive.monitoring.driver_monitor import DriverStatus
from selfdrive.locationd.calibrationd import Calibration


def dmonitoringd_thread(sm=None, pm=None):
  if pm is None:

            

Reported by Pylint.

              import cereal.messaging as messaging
from selfdrive.controls.lib.events import Events
from selfdrive.monitoring.driver_monitor import DriverStatus
from selfdrive.locationd.calibrationd import Calibration


def dmonitoringd_thread(sm=None, pm=None):
  if pm is None:
    pm = messaging.PubMaster(['driverMonitoringState'])

            

Reported by Pylint.

                  driver_status.get_pose(sm['driverState'], sm['liveCalibration'].rpyCalib, sm['carState'].vEgo, sm['controlsState'].enabled)

    # Block engaging after max number of distrations
    if driver_status.terminal_alert_cnt >= driver_status.settings._MAX_TERMINAL_ALERTS or \
       driver_status.terminal_time >= driver_status.settings._MAX_TERMINAL_DURATION:
      events.add(car.CarEvent.EventName.tooDistracted)

    # Update events from driver state
    driver_status.update(events, driver_engaged, sm['controlsState'].enabled, sm['carState'].standstill)

            

Reported by Pylint.

              
    # Block engaging after max number of distrations
    if driver_status.terminal_alert_cnt >= driver_status.settings._MAX_TERMINAL_ALERTS or \
       driver_status.terminal_time >= driver_status.settings._MAX_TERMINAL_DURATION:
      events.add(car.CarEvent.EventName.tooDistracted)

    # Update events from driver state
    driver_status.update(events, driver_engaged, sm['controlsState'].enabled, sm['carState'].standstill)


            

Reported by Pylint.

              #!/usr/bin/env python3
from cereal import car
from common.params import Params
import cereal.messaging as messaging
from selfdrive.controls.lib.events import Events
from selfdrive.monitoring.driver_monitor import DriverStatus
from selfdrive.locationd.calibrationd import Calibration



            

Reported by Pylint.

              from selfdrive.locationd.calibrationd import Calibration


def dmonitoringd_thread(sm=None, pm=None):
  if pm is None:
    pm = messaging.PubMaster(['driverMonitoringState'])

  if sm is None:
    sm = messaging.SubMaster(['driverState', 'liveCalibration', 'carState', 'controlsState', 'modelV2'], poll=['driverState'])

            

Reported by Pylint.

              import os
import numpy as np

from selfdrive.test.helpers import with_processes
from selfdrive.camerad.snapshot.snapshot import get_snapshots

from selfdrive.hardware import EON, TICI

TEST_TIME = 45

            

Reported by Pylint.

              import numpy as np

from selfdrive.test.helpers import with_processes
from selfdrive.camerad.snapshot.snapshot import get_snapshots

from selfdrive.hardware import EON, TICI

TEST_TIME = 45
REPEAT = 5

            

Reported by Pylint.

              from selfdrive.test.helpers import with_processes
from selfdrive.camerad.snapshot.snapshot import get_snapshots

from selfdrive.hardware import EON, TICI

TEST_TIME = 45
REPEAT = 5

os.environ["SEND_ROAD"] = "1"

            

Reported by Pylint.

              #!/usr/bin/env python3

import time
import unittest
import os
import numpy as np

from selfdrive.test.helpers import with_processes
from selfdrive.camerad.snapshot.snapshot import get_snapshots

            

Reported by Pylint.

              os.environ["SEND_ROAD"] = "1"
os.environ["SEND_DRIVER"] = "1"
if TICI:
  os.environ["SEND_WIDE_ROAD"] = "1"

class TestCamerad(unittest.TestCase):
  @classmethod
  def setUpClass(cls):
    if not (EON or TICI):

            

Reported by Pylint.

              if TICI:
  os.environ["SEND_WIDE_ROAD"] = "1"

class TestCamerad(unittest.TestCase):
  @classmethod
  def setUpClass(cls):
    if not (EON or TICI):
      raise unittest.SkipTest


            

Reported by Pylint.

                os.environ["SEND_WIDE_ROAD"] = "1"

class TestCamerad(unittest.TestCase):
  @classmethod
  def setUpClass(cls):
    if not (EON or TICI):
      raise unittest.SkipTest

  def _numpy_rgb2gray(self, im):

            

Reported by Pylint.

              
class TestCamerad(unittest.TestCase):
  @classmethod
  def setUpClass(cls):
    if not (EON or TICI):
      raise unittest.SkipTest

  def _numpy_rgb2gray(self, im):
    ret = np.clip(im[:,:,2] * 0.114 + im[:,:,1] * 0.587 + im[:,:,0] * 0.299, 0, 255).astype(np.uint8)

            

Reported by Pylint.

              class TestCamerad(unittest.TestCase):
  @classmethod
  def setUpClass(cls):
    if not (EON or TICI):
      raise unittest.SkipTest

  def _numpy_rgb2gray(self, im):
    ret = np.clip(im[:,:,2] * 0.114 + im[:,:,1] * 0.587 + im[:,:,0] * 0.299, 0, 255).astype(np.uint8)
    return ret

            

Reported by Pylint.

                @classmethod
  def setUpClass(cls):
    if not (EON or TICI):
      raise unittest.SkipTest

  def _numpy_rgb2gray(self, im):
    ret = np.clip(im[:,:,2] * 0.114 + im[:,:,1] * 0.587 + im[:,:,0] * 0.299, 0, 255).astype(np.uint8)
    return ret


            

Reported by Pylint.

              #

import os
from casadi import *
from .utils import ALLOWED_CASADI_VERSIONS, is_empty, casadi_version_warning

def generate_c_code_explicit_ode( model, opts ):

    casadi_version = CasadiMeta.version()

            

Reported by Pylint.

              
import os
from casadi import *
from .utils import ALLOWED_CASADI_VERSIONS, is_empty, casadi_version_warning

def generate_c_code_explicit_ode( model, opts ):

    casadi_version = CasadiMeta.version()
    casadi_opts = dict(mex=False, casadi_int='int', casadi_real='double')

            

Reported by Pylint.

              
def generate_c_code_explicit_ode( model, opts ):

    casadi_version = CasadiMeta.version()
    casadi_opts = dict(mex=False, casadi_int='int', casadi_real='double')
    if casadi_version not in (ALLOWED_CASADI_VERSIONS):
        casadi_version_warning(casadi_version)



            

Reported by Pylint.

                  nx = x.size()[0]
    nu = u.size()[0]

    if isinstance(f_expl, casadi.MX):
        symbol = MX.sym
    elif isinstance(f_expl, casadi.SX):
        symbol = SX.sym
    else:
        raise Exception("Invalid type for f_expl! Possible types are 'SX' and 'MX'. Exiting.")

            

Reported by Pylint.

                  nu = u.size()[0]

    if isinstance(f_expl, casadi.MX):
        symbol = MX.sym
    elif isinstance(f_expl, casadi.SX):
        symbol = SX.sym
    else:
        raise Exception("Invalid type for f_expl! Possible types are 'SX' and 'MX'. Exiting.")
    ## set up functions to be exported

            

Reported by Pylint.

              
    if isinstance(f_expl, casadi.MX):
        symbol = MX.sym
    elif isinstance(f_expl, casadi.SX):
        symbol = SX.sym
    else:
        raise Exception("Invalid type for f_expl! Possible types are 'SX' and 'MX'. Exiting.")
    ## set up functions to be exported
    Sx = symbol('Sx', nx, nx)

            

Reported by Pylint.

                  if isinstance(f_expl, casadi.MX):
        symbol = MX.sym
    elif isinstance(f_expl, casadi.SX):
        symbol = SX.sym
    else:
        raise Exception("Invalid type for f_expl! Possible types are 'SX' and 'MX'. Exiting.")
    ## set up functions to be exported
    Sx = symbol('Sx', nx, nx)
    Sp = symbol('Sp', nx, nu)

            

Reported by Pylint.

                  fun_name = model_name + '_expl_ode_fun'

    ## Set up functions
    expl_ode_fun = Function(fun_name, [x, u, p], [f_expl])

    vdeX = jtimes(f_expl,x,Sx)
    vdeP = jacobian(f_expl,u) + jtimes(f_expl,x,Sp)

    fun_name = model_name + '_expl_vde_forw'

            

Reported by Pylint.

                  ## Set up functions
    expl_ode_fun = Function(fun_name, [x, u, p], [f_expl])

    vdeX = jtimes(f_expl,x,Sx)
    vdeP = jacobian(f_expl,u) + jtimes(f_expl,x,Sp)

    fun_name = model_name + '_expl_vde_forw'

    expl_vde_forw = Function(fun_name, [x, Sx, Sp, u, p], [f_expl, vdeX, vdeP])

            

Reported by Pylint.

                  expl_ode_fun = Function(fun_name, [x, u, p], [f_expl])

    vdeX = jtimes(f_expl,x,Sx)
    vdeP = jacobian(f_expl,u) + jtimes(f_expl,x,Sp)

    fun_name = model_name + '_expl_vde_forw'

    expl_vde_forw = Function(fun_name, [x, Sx, Sp, u, p], [f_expl, vdeX, vdeP])


            

Reported by Pylint.

              #

import os
from casadi import *
from .utils import ALLOWED_CASADI_VERSIONS, is_empty, casadi_length, casadi_version_warning

def generate_c_code_implicit_ode( model, opts ):

    casadi_version = CasadiMeta.version()

            

Reported by Pylint.

              
import os
from casadi import *
from .utils import ALLOWED_CASADI_VERSIONS, is_empty, casadi_length, casadi_version_warning

def generate_c_code_implicit_ode( model, opts ):

    casadi_version = CasadiMeta.version()
    casadi_opts = dict(mex=False, casadi_int='int', casadi_real='double')

            

Reported by Pylint.

              
def generate_c_code_implicit_ode( model, opts ):

    casadi_version = CasadiMeta.version()
    casadi_opts = dict(mex=False, casadi_int='int', casadi_real='double')
    if casadi_version not in (ALLOWED_CASADI_VERSIONS):
        casadi_version_warning(casadi_version)

    generate_hess = opts["generate_hess"]

            

Reported by Pylint.

                  nz = casadi_length(z)

    ## generate jacobians
    jac_x       = jacobian(f_impl, x)
    jac_xdot    = jacobian(f_impl, xdot)
    jac_u       = jacobian(f_impl, u)
    jac_z       = jacobian(f_impl, z)

    ## generate hessian

            

Reported by Pylint.

              
    ## generate jacobians
    jac_x       = jacobian(f_impl, x)
    jac_xdot    = jacobian(f_impl, xdot)
    jac_u       = jacobian(f_impl, u)
    jac_z       = jacobian(f_impl, z)

    ## generate hessian
    x_xdot_z_u = vertcat(x, xdot, z, u)

            

Reported by Pylint.

                  ## generate jacobians
    jac_x       = jacobian(f_impl, x)
    jac_xdot    = jacobian(f_impl, xdot)
    jac_u       = jacobian(f_impl, u)
    jac_z       = jacobian(f_impl, z)

    ## generate hessian
    x_xdot_z_u = vertcat(x, xdot, z, u)


            

Reported by Pylint.

                  jac_x       = jacobian(f_impl, x)
    jac_xdot    = jacobian(f_impl, xdot)
    jac_u       = jacobian(f_impl, u)
    jac_z       = jacobian(f_impl, z)

    ## generate hessian
    x_xdot_z_u = vertcat(x, xdot, z, u)

    if isinstance(x, casadi.MX):

            

Reported by Pylint.

                  jac_z       = jacobian(f_impl, z)

    ## generate hessian
    x_xdot_z_u = vertcat(x, xdot, z, u)

    if isinstance(x, casadi.MX):
        symbol = MX.sym
    else:
        symbol = SX.sym

            

Reported by Pylint.

                  ## generate hessian
    x_xdot_z_u = vertcat(x, xdot, z, u)

    if isinstance(x, casadi.MX):
        symbol = MX.sym
    else:
        symbol = SX.sym

    multiplier  = symbol('multiplier', nx + nz)

            

Reported by Pylint.

                  x_xdot_z_u = vertcat(x, xdot, z, u)

    if isinstance(x, casadi.MX):
        symbol = MX.sym
    else:
        symbol = SX.sym

    multiplier  = symbol('multiplier', nx + nz)


            

Reported by Pylint.

              import time
import subprocess

from cereal import log, car
import cereal.messaging as messaging
from selfdrive.test.helpers import phone_only, with_processes
from common.realtime import DT_CTRL
from selfdrive.hardware import HARDWARE


            

Reported by Pylint.

              import subprocess

from cereal import log, car
import cereal.messaging as messaging
from selfdrive.test.helpers import phone_only, with_processes
from common.realtime import DT_CTRL
from selfdrive.hardware import HARDWARE

AudibleAlert = car.CarControl.HUDControl.AudibleAlert

            

Reported by Pylint.

              
from cereal import log, car
import cereal.messaging as messaging
from selfdrive.test.helpers import phone_only, with_processes
from common.realtime import DT_CTRL
from selfdrive.hardware import HARDWARE

AudibleAlert = car.CarControl.HUDControl.AudibleAlert


            

Reported by Pylint.

              from cereal import log, car
import cereal.messaging as messaging
from selfdrive.test.helpers import phone_only, with_processes
from common.realtime import DT_CTRL
from selfdrive.hardware import HARDWARE

AudibleAlert = car.CarControl.HUDControl.AudibleAlert

SOUNDS = {

            

Reported by Pylint.

              import cereal.messaging as messaging
from selfdrive.test.helpers import phone_only, with_processes
from common.realtime import DT_CTRL
from selfdrive.hardware import HARDWARE

AudibleAlert = car.CarControl.HUDControl.AudibleAlert

SOUNDS = {
  # sound: total writes

            

Reported by Pylint.

              #!/usr/bin/env python3
import time
import subprocess

from cereal import log, car
import cereal.messaging as messaging
from selfdrive.test.helpers import phone_only, with_processes
from common.realtime import DT_CTRL
from selfdrive.hardware import HARDWARE

            

Reported by Pylint.

              #!/usr/bin/env python3
import time
import subprocess

from cereal import log, car
import cereal.messaging as messaging
from selfdrive.test.helpers import phone_only, with_processes
from common.realtime import DT_CTRL
from selfdrive.hardware import HARDWARE

            

Reported by Bandit.

              import cereal.messaging as messaging
from selfdrive.test.helpers import phone_only, with_processes
from common.realtime import DT_CTRL
from selfdrive.hardware import HARDWARE

AudibleAlert = car.CarControl.HUDControl.AudibleAlert

SOUNDS = {
  # sound: total writes

            

Reported by Pylint.

                AudibleAlert.chimeWarningRepeat: 468,
}

def get_total_writes():
  audio_flinger = subprocess.check_output('dumpsys media.audio_flinger', shell=True, encoding='utf-8').strip()
  write_lines = [l for l in audio_flinger.split('\n') if l.strip().startswith('Total writes')]
  return sum([int(l.split(':')[1]) for l in write_lines])

@phone_only

            

Reported by Pylint.

              }

def get_total_writes():
  audio_flinger = subprocess.check_output('dumpsys media.audio_flinger', shell=True, encoding='utf-8').strip()
  write_lines = [l for l in audio_flinger.split('\n') if l.strip().startswith('Total writes')]
  return sum([int(l.split(':')[1]) for l in write_lines])

@phone_only
def test_sound_card_init():

            

Reported by Pylint.

              import time
import unittest

import cereal.messaging as messaging
from selfdrive.test.helpers import with_processes

# only tests for EON and TICI
from selfdrive.hardware import EON, TICI


            

Reported by Pylint.

              import unittest

import cereal.messaging as messaging
from selfdrive.test.helpers import with_processes

# only tests for EON and TICI
from selfdrive.hardware import EON, TICI

TEST_TIMESPAN = 30 # random.randint(60, 180) # seconds

            

Reported by Pylint.

              from selfdrive.test.helpers import with_processes

# only tests for EON and TICI
from selfdrive.hardware import EON, TICI

TEST_TIMESPAN = 30 # random.randint(60, 180) # seconds
SKIP_FRAME_TOLERANCE = 0
LAG_FRAME_TOLERANCE = 2 # ms


            

Reported by Pylint.

              #!/usr/bin/env python3

import time
import unittest

import cereal.messaging as messaging
from selfdrive.test.helpers import with_processes

# only tests for EON and TICI

            

Reported by Pylint.

              }

if TICI:
  CAMERAS["driverCameraState"] = FPS_BASELINE
  CAMERAS["wideRoadCameraState"] = FPS_BASELINE

class TestCamerad(unittest.TestCase):
  @classmethod
  def setUpClass(cls):

            

Reported by Pylint.

              
if TICI:
  CAMERAS["driverCameraState"] = FPS_BASELINE
  CAMERAS["wideRoadCameraState"] = FPS_BASELINE

class TestCamerad(unittest.TestCase):
  @classmethod
  def setUpClass(cls):
    if not (EON or TICI):

            

Reported by Pylint.

                CAMERAS["driverCameraState"] = FPS_BASELINE
  CAMERAS["wideRoadCameraState"] = FPS_BASELINE

class TestCamerad(unittest.TestCase):
  @classmethod
  def setUpClass(cls):
    if not (EON or TICI):
      raise unittest.SkipTest


            

Reported by Pylint.

                CAMERAS["wideRoadCameraState"] = FPS_BASELINE

class TestCamerad(unittest.TestCase):
  @classmethod
  def setUpClass(cls):
    if not (EON or TICI):
      raise unittest.SkipTest

  @with_processes(['camerad'])

            

Reported by Pylint.

              
class TestCamerad(unittest.TestCase):
  @classmethod
  def setUpClass(cls):
    if not (EON or TICI):
      raise unittest.SkipTest

  @with_processes(['camerad'])
  def test_frame_packets(self):

            

Reported by Pylint.

              class TestCamerad(unittest.TestCase):
  @classmethod
  def setUpClass(cls):
    if not (EON or TICI):
      raise unittest.SkipTest

  @with_processes(['camerad'])
  def test_frame_packets(self):
    print("checking frame pkts continuity")

            

Reported by Pylint.

              import re
import SCons
from SCons.Action import Action
from SCons.Scanner import Scanner

pyx_from_import_re = re.compile(r'^from\s+(\S+)\s+cimport', re.M)
pyx_import_re = re.compile(r'^cimport\s+(\S+)', re.M)
cdef_import_re = re.compile(r'^cdef extern from\s+.(\S+).:', re.M)


            

Reported by Pylint.

              import re
import SCons
from SCons.Action import Action
from SCons.Scanner import Scanner

pyx_from_import_re = re.compile(r'^from\s+(\S+)\s+cimport', re.M)
pyx_import_re = re.compile(r'^cimport\s+(\S+)', re.M)
cdef_import_re = re.compile(r'^cdef extern from\s+.(\S+).:', re.M)


            

Reported by Pylint.

              import re
import SCons
from SCons.Action import Action
from SCons.Scanner import Scanner

pyx_from_import_re = re.compile(r'^from\s+(\S+)\s+cimport', re.M)
pyx_import_re = re.compile(r'^cimport\s+(\S+)', re.M)
cdef_import_re = re.compile(r'^cdef extern from\s+.(\S+).:', re.M)


            

Reported by Pylint.

              cdef_import_re = re.compile(r'^cdef extern from\s+.(\S+).:', re.M)


def pyx_scan(node, env, path, arg=None):
  contents = node.get_text_contents()

  # from <module> cimport ...
  matches = pyx_from_import_re.findall(contents)
  # cimport <module>

            

Reported by Pylint.

              cdef_import_re = re.compile(r'^cdef extern from\s+.(\S+).:', re.M)


def pyx_scan(node, env, path, arg=None):
  contents = node.get_text_contents()

  # from <module> cimport ...
  matches = pyx_from_import_re.findall(contents)
  # cimport <module>

            

Reported by Pylint.

                  env['BUILDERS']['Cython'] = cython
  return cython

def cython_suffix_emitter(env, source):
  return "$CYTHONCFILESUFFIX"

def generate(env):
  env["CYTHON"] = "cythonize"
  env["CYTHONCOM"] = "$CYTHON $CYTHONFLAGS $SOURCE"

            

Reported by Pylint.

                  env['BUILDERS']['Cython'] = cython
  return cython

def cython_suffix_emitter(env, source):
  return "$CYTHONCFILESUFFIX"

def generate(env):
  env["CYTHON"] = "cythonize"
  env["CYTHONCOM"] = "$CYTHON $CYTHONFLAGS $SOURCE"

            

Reported by Pylint.

              
  create_builder(env)

def exists(env):
  return True

            

Reported by Pylint.

              import re
import SCons
from SCons.Action import Action
from SCons.Scanner import Scanner

pyx_from_import_re = re.compile(r'^from\s+(\S+)\s+cimport', re.M)
pyx_import_re = re.compile(r'^cimport\s+(\S+)', re.M)
cdef_import_re = re.compile(r'^cdef extern from\s+.(\S+).:', re.M)


            

Reported by Pylint.

              cdef_import_re = re.compile(r'^cdef extern from\s+.(\S+).:', re.M)


def pyx_scan(node, env, path, arg=None):
  contents = node.get_text_contents()

  # from <module> cimport ...
  matches = pyx_from_import_re.findall(contents)
  # cimport <module>

            

Reported by Pylint.

                      if msg in sent_msgs:
          continue
        sent_msgs[msg] = ''.join([random.choice(string.ascii_letters) for _ in range(random.randrange(2, 20))])
        os.system(f"log -t '{sent_msgs[msg]}' '{msg}'")

      time.sleep(1)
      msgs = messaging.drain_sock(sock)
      for m in msgs:
        self.assertTrue(m.valid)

            

Reported by Bandit.

              import time
import unittest

import cereal.messaging as messaging
from selfdrive.test.helpers import with_processes

class TestLogcatdAndroid(unittest.TestCase):

  @with_processes(['logcatd'])

            

Reported by Pylint.

              import unittest

import cereal.messaging as messaging
from selfdrive.test.helpers import with_processes

class TestLogcatdAndroid(unittest.TestCase):

  @with_processes(['logcatd'])
  def test_log(self):

            

Reported by Pylint.

              #!/usr/bin/env python3
import os
import random
import string
import time
import unittest

import cereal.messaging as messaging
from selfdrive.test.helpers import with_processes

            

Reported by Pylint.

              import cereal.messaging as messaging
from selfdrive.test.helpers import with_processes

class TestLogcatdAndroid(unittest.TestCase):

  @with_processes(['logcatd'])
  def test_log(self):
    sock = messaging.sub_sock("androidLog", conflate=False)


            

Reported by Pylint.

              
class TestLogcatdAndroid(unittest.TestCase):

  @with_processes(['logcatd'])
  def test_log(self):
    sock = messaging.sub_sock("androidLog", conflate=False)

    # make sure sockets are ready
    time.sleep(1)

            

Reported by Pylint.

              class TestLogcatdAndroid(unittest.TestCase):

  @with_processes(['logcatd'])
  def test_log(self):
    sock = messaging.sub_sock("androidLog", conflate=False)

    # make sure sockets are ready
    time.sleep(1)
    messaging.drain_sock(sock)

            

Reported by Pylint.

              class TestLogcatdAndroid(unittest.TestCase):

  @with_processes(['logcatd'])
  def test_log(self):
    sock = messaging.sub_sock("androidLog", conflate=False)

    # make sure sockets are ready
    time.sleep(1)
    messaging.drain_sock(sock)

            

Reported by Pylint.

              
  @with_processes(['logcatd'])
  def test_log(self):
    sock = messaging.sub_sock("androidLog", conflate=False)

    # make sure sockets are ready
    time.sleep(1)
    messaging.drain_sock(sock)


            

Reported by Pylint.

                  sock = messaging.sub_sock("androidLog", conflate=False)

    # make sure sockets are ready
    time.sleep(1)
    messaging.drain_sock(sock)

    for _ in range(random.randint(2, 10)):
      # write some log messages
      sent_msgs = {}

            

Reported by Pylint.