Пример #1
0
 def do_GET(self):
     log = self.server.log
     log.debug("GET from %s:%d" % self.client_address)
     log.debug("Request: %s" % self.path)
     urlparts = urlparse.urlsplit(self.path)
     query = urlparse.parse_qs(urlparts.query)
     if urlparts.path in ('/boot', '/linux'):
         if 'uuid' in query:
             uuids = query['uuid']
             for uuid in uuids:
                 uuid = uuid.upper().strip()
                 authorized = self.server.uuids.get(uuid, False)
                 log.info(
                     'UUID %s is %s' %
                     (uuid, authorized and 'authorized' or 'rejected'))
                 if authorized:
                     break
         else:
             authorized = False
             log.warn('Request does not specify a UUID')
         if authorized:
             response = '\n\n'  # HTTP protocol, line feed after headers
             # dummy generation of a tester number
             tester = sum([to_int('0x%s' % x) for x in uuid.split('-')])
             clientname = 'Tester-%03d' % (tester & 0xFF)
             log.info("UUID %s is assigned as %s" % (uuid, clientname))
             response += 'Client: %s\n' % clientname
             filename = 'define_filename_here'
             if urlparts.path == '/linux':
                 response += 'File: %s\n' % filename
             self.send_response(200, 'Ok')
             self.wfile.write(response)
             return
     self.send_error(401, 'Not authorized')
     return
Пример #2
0
 def do_GET(self):
     log = self.server.log
     log.debug("GET from %s:%d" % self.client_address)
     log.debug("Request: %s" % self.path)
     urlparts = urlparse.urlsplit(self.path)
     query = urlparse.parse_qs(urlparts.query)
     if urlparts.path in ('/boot', '/linux'):
         if 'uuid' in query:
             uuids = query['uuid']
             for uuid in uuids:
                 uuid = uuid.upper().strip()
                 authorized = self.server.uuids.get(uuid, False)
                 log.info('UUID %s is %s' % (
                     uuid, authorized and 'authorized' or 'rejected'))
                 if authorized:
                     break
         else:
             authorized = False
             log.warn('Request does not specify a UUID')
         if authorized:
             response = '\n\n'  # HTTP protocol, line feed after headers
             # dummy generation of a tester number
             tester = sum([to_int('0x%s' % x) for x in uuid.split('-')])
             clientname = 'Tester-%03d' % (tester & 0xFF)
             log.info("UUID %s is assigned as %s" % (uuid, clientname))
             response += 'Client: %s\n' % clientname
             filename = 'define_filename_here'
             if urlparts.path == '/linux':
                 response += 'File: %s\n' % filename
             self.send_response(200, 'Ok')
             self.wfile.write(response)
             return
     self.send_error(401, 'Not authorized')
     return
Пример #3
0
def r2_matrix_element(n, l, ml, ms, n2, l2, ml2, ms2):
    """
  Compute the matrix element <n2 l2 | r^2 | n l>.
  """
    # nuclear.fis.ucm.es/PDFN/documentos/Nilsson_Doct.pdf
    if ml != ml2 or ms != ms2 or (n - n2) % 2 != 0 or (n - n2) > 2:
        return 0.0
    # If d were a half-integer, then we couldn't have both sigma! and (d-1-sigma)! make sense. This seems to tell me that
    # if N-l isn't even, the matrix element must vanish. This sort of makes sense given UCM's notation lowercase n for my d, probably
    # similar to hydrogen atom's n.
    if (n - l) % 2 != 0 or (n2 - l2) % 2 != 0:
        return 0.0
    # Beyond this point, we don't look at ms or ms2 anymore, so all spins are integers. Only p is half-integer. d, d2, mu, nu, sigma are integers.
    p = 0.5 * (l + l2 + 3)
    mu = util.to_int(p - l2 - 0.5)
    nu = util.to_int(p - l - 0.5)
    d = util.to_int(0.5 * (n - l) + 1)  # UCM's lowercase n
    d2 = util.to_int(0.5 * (n2 - l2) + 1)
    sum = 0.0
    for sigma in range(
            max(0, d2 - mu - 1, d - nu - 1),
            min(d - 1, d2 - 1) + 1
    ):  # guess range based on criterion that all 5 inputs to factorials should be >=0
        ln_term = ln_gamma(p + sigma + 1) - (
            ln_fac(sigma) + ln_fac(d2 - 1 - sigma) + ln_fac(d - 1 - sigma) +
            ln_fac(sigma + mu - d2 + 1) + ln_fac(sigma + nu - d + 1))
        term = math.exp(ln_term)
        sum = sum + term
    ln_stuff = ln_fac(d2 - 1) + ln_fac(d - 1) - (ln_gamma(d2 + l2 + 0.5) +
                                                 ln_gamma(d + l + 0.5))
    if mu < 0 or nu < 0:
        print(
            "negative mu or nu in r2_matrix_element -- this shoudln't happen")
        print("p,d,mu,nu=", p, d, mu, nu)
        print("n,l,ml,ms,    n2,l2,ml2,ms2=", n, l, ml, ms, "    ", n2, l2,
              ml2, ms2)
    ln_stuff2 = ln_fac(mu) + ln_fac(nu)
    result = sum * math.exp(0.5 * ln_stuff + ln_stuff2)
    if (d + d2) % 2 != 0:
        result = -result
        # ... Note that this is the only place where a sign can occur. The gamma function inside the sum is always
        #     positive, because both sigma and p are nonnegative.
    # ECM has a (unitful?) factor of b^2, but doesn't include that factor in their sample expressions for <N|...|N+2>.
    # They define b as sqrt(hbar/m*omega0), so when we compute energies in units of hbar*omega0, this should not be an issue.
    return result
Пример #4
0
    def __init__(self, protocol_name, post_interval=None):
        """Initializer for the class RESTThread."""

        threading.Thread.__init__(self, name=protocol_name)
        self.setDaemon(True)
        self.queue = Queue.Queue()
        self.protocol_name = protocol_name
        self.post_interval = to_int(post_interval)
        self.lastpost = 0
Пример #5
0
def main():

    if len(sys.argv) < 3:
        usage()
        print 'ERROR: min 3 arguments'
        exit(1)

    port_name = sys.argv[1]
    command = sys.argv[2]

    mae = MaestroSerial(port_name,9600)

    if command == 'settarget':
        channel = to_int(3, 0, 23, 'channel')
        value   = to_int(4, 0, 3000, 'value')
        if channel == None or value == None: exit(1)
        mae.set_target(channel, value)

    elif command == 'setspeed':
        channel = to_int(3, 0, 23, 'channel')
        value   = to_int(4, 0, 3000, 'value')
        if channel == None or value == None: exit(1)
        mae.set_speed(channel, value)


    elif command == 'setmultiple':
        channel = to_int(3, 0, 23, 'channel')
        value1  = to_int(4, 0, 3000, 'value1')
        value2  = to_int(5, 0, 3000, 'value2')
        value3  = to_int(6, 0, 3000, 'value3')
        mae.set_multiple(channel,(value1,value2,value3))
        pass

    elif command == 'getposition':
        channel = to_int(3, 0, 23, 'channel')
        if channel == None: exit(1)
        res = mae.get_position(channel)
        print res

    elif command == 'getmoving':
        res = mae.get_moving()
        print res

    else:
        usage()
        print "ERROR: Unknown command"

    return
Пример #6
0
 def set(self, cursor=None, facebook_id=None, user_id=None, venue_id=None,
         name=None, address=None, country=None, phone=None, email=None,
         email_verified=None, category_id=None, headline=None, tonight=None,
         website=None, facebook=None, twitter=None, v_facebook_id=None,
         twitter_id=None, twitter_token=None, twitter_secret=None, lat=None,
         lon=None, official=None, verified=None, customer_spend=None,
         authenticated=None, creator_version=None, **kwargs):
     data = {'name':           name,
             'address':        address,
             'country':        country,
             'phone':          phone,
             'email':          email,
             'email_verified': util.to_bool(email_verified),
             'category_id':    util.to_int(category_id),
             'headline':       headline,
             'tonight':        tonight,
             'website':        website,
             'facebook':       facebook,
             'twitter':        twitter,
             'facebook_id':    v_facebook_id,
             'twitter_id':     twitter_id,
             'twitter_token':  twitter_token,
             'twitter_secret': twitter_secret,
             'lat':            util.to_float(lat),
             'lon':            util.to_float(lon),
             'official':       util.to_bool(official),
             'verified':       util.to_bool(verified),
             'customer_spend': util.to_float(customer_spend),
             'authenticated':  util.to_bool(authenticated),
             'creator':        user_id,
             'creator_version': creator_version}
     columns = []
     values = []
     for key, val in data.iteritems():
         if val != None:
             columns.append(key)
             values.append(val)
     if venue_id:
         qry = {'update':     'venues',
                'set_values': columns,
                'where':      'id = ?'}
         values.append(venue_id)
         cursor.execute(util.query(**qry), values)
     else:
         qry = {'insert_into': 'venues',
                'columns':     columns}
         cursor.execute(util.query(**qry), values)
     cursor.execute(util.query(last_id=True))
     return int(cursor.fetchone().identity)
Пример #7
0
def main():
    if len(sys.argv) < 3:
        usage()
        print 'ERROR: min 3 arguments'
        exit(1)

    port_name = sys.argv[1]
    command = sys.argv[2]

    legs = Legs(port_name,9600)

    if command == 'updatestatus':
        ls = legs.get_status()
        ls.print_status()
    elif command == 'setall':
        speed = to_int(3, 0, 3000, 'speed')
        value = to_int(4, 0, 3000, 'value')
        ls = LegsStatus()
        ls.set(value,value,value,value,value,value,value,value,value,value,value,value,value,value,value,value,value,value)
        legs.set_all(speed, ls)
    elif command == 'setrand':
        speed = to_int(3, 0, 3000, 'speed')
        value = to_int(4, 0, 3000, 'value')
        offset = value-1500
        ls = LegsStatus()
        ls.set(
            1500,1500+offset,1500+offset*10,
            1500,1500,1500,
            1500,1500,1500,
            1500,1500,1500,
            1500,1500,1500,
            1500,1500,1500)
        legs.set_all_sync(speed, ls)
    else:
        usage()
        print "ERROR: Unknown command"
Пример #8
0
    def main(self):
        #Limpiamos consola, imprimimos las instrucciones 
        #y pedimos una opcion
        clear()
        self.__instruc()
        print("  Presione:")
        print("   1.- Para comenzar")
        print("   0.- Para salir")

        option=to_int(input(" Ingrese su opcion: "))
        
        if option==1: #Iniciar el juego
            clear()
            self.table.begin()
        elif option == 0: #Salir del juego
            exit() 
        else: # Volver a mostrar el menu
            self.main()
Пример #9
0
 def __init__(self, host=SERVER_DEFAULT, port=PORT_DEFAULT):
     self.host = host
     self.port = to_int(port)
     self._conn = ClientConnection(self.host, self.port, timeout=REQUEST_TIMEOUT)
Пример #10
0
 def set(self, cursor=None, facebook_id=None, twitter_token=None,
         facebook=None, twitter=None, forename=None, surname=None, age=None,
         birth_day=None, birth_month=None, birth_year=None, gender=None,
         employee=None, country=None, language=None, email=None, top5=None,
         twitter_id=None, twitter_secret=None, save_locally=None,
         app_version=None, iphone_model=None, ios_version=None,
         last_facebook=None, last_twitter=None, **kwargs):
     if not facebook_id:
         raise cherrypy.HTTPError(403)
     qry = {'select':   'COUNT(id) AS count',
            'table':    'users',
            'where':    'facebook_id = ?'}
     cursor.execute(util.query(**qry), (facebook_id,))
     res = cursor.fetchone().count
     data = {'twitter_id':     twitter_id,
             'twitter_token':  twitter_token,
             'twitter_secret': twitter_secret,
             'facebook':       facebook,
             'twitter':        twitter,
             'forename':       forename,
             'surname':        surname,
             'age':            util.to_int(age),
             'birth_day':      util.to_int(birth_day),
             'birth_month':    util.to_int(birth_month),
             'birth_year':     util.to_int(birth_year),
             'gender':         gender,
             'employee':       util.to_bool(employee),
             'country':        country,
             'language':       language,
             'email':          email,
             'top5':           util.to_bool(top5),
             'save_locally':   util.to_bool(save_locally),
             'app_version':    app_version,
             'iphone_model':   iphone_model,
             'ios_version':    ios_version,
             'last_login':     util.now(),
             'last_facebook':  util.to_bool(last_facebook),
             'last_twitter':   util.to_bool(last_twitter)}
     columns = []
     values = []
     for key, val in data.iteritems():
         if val != None:
             columns.append(key)
             if val is not True and val is not False:
                 values.append(val)
             else:
                 if val:
                     values.append('1')
                 else:
                     values.append('0')
     values.append(facebook_id)
     if res:
         qry = {'update':     'users',
                'set_values': columns,
                'where':      'facebook_id = ?'}
         cursor.execute(util.query(**qry), values)
     else:
         columns.append('facebook_id')
         columns.append('joined')
         values.append(util.now())
         qry = {'insert_into': 'users',
                'columns':     columns}
         cursor.execute(util.query(**qry), values)
     qry = {'select':   'id',
            'table':    'users',
            'where':    'facebook_id = ?',
            'order_by': 'id',
            'limit':    1}
     cursor.execute(util.query(**qry), (facebook_id,))
     user_id = cursor.fetchone().id
     return self.retrieve(cursor=cursor, user_id=user_id)
Пример #11
0
class BaseConfig:
    """Base configuration"""

    load_dotenv(".env")

    """ General """
    FLASK_ENV = os.getenv("FLASK_ENV", "development")
    DEFAULT_COLLECTION_INTERVAL = {"hours": 1}
    ENV_NAME = os.getenv("ENV_NAME", socket.gethostname())
    DEFAULT_PROJECTION = "wgs84"

    """ Sentry """
    SENTRY_ENABLED = to_bool(os.getenv("SENTRY_ENABLED"))
    SENTRY_DSN = os.getenv("SENTRY_DSN", None)
    SENTRY_LEVEL = os.getenv("SENTRY_LEVEL", 40)
    SENTRY_EVENT_LEVEL = os.getenv("SENTRY_EVENT_LEVEL", 40)
    SENTRY_ENV_NAME = os.getenv("SENTRY_ENV_NAME", ENV_NAME)
    SENTRY_RELEASE = f"{project}-{version}"

    """ Datadog """
    DATADOG_ENABLED = to_bool(os.getenv("DATADOG_ENABLED"))
    DATADOG_API_KEY = os.getenv("DATADOG_API_KEY", os.getenv("DD_API_KEY", None))
    DATADOG_APP_KEY = os.getenv("DATADOG_APP_KEY", os.getenv("DD_APP_KEY", None))
    DATADOG_DEFAULT_TAGS = {
        "environment": ENVIRONMENT_MAP.get(FLASK_ENV, FLASK_ENV),
        "service_name": project,
        "service_version": version,
    }

    """ Config """
    CONFIG_BASEPATH = "./config"
    COLLECTOR_CONFIG_PATH = abs_path(*os.getenv('COLLECTOR_CONFIG_PATH', CONFIG_BASEPATH+"/collector.yaml").rsplit("/", 1))  # type: ignore # noqa

    COLLECTOR_CONFIG_PATH = abs_path(CONFIG_BASEPATH, "collector.yaml")
    COLLECTOR_CONFIG = load_config(COLLECTOR_CONFIG_PATH)
    PARSER_CONFIG_PATH = abs_path(CONFIG_BASEPATH, "parsers.yaml")
    PARSER_CONFIG = load_config(PARSER_CONFIG_PATH)
    QUERY_PATH = abs_path(CONFIG_BASEPATH, "templates/queries")
    EXPORT_PATH = abs_path(CONFIG_BASEPATH, "templates/exports")

    """ Logging """
    LOG_LEVEL = os.getenv("LOG_LEVEL", 20)
    LOG_FORMAT = os.getenv("LOG_FORMAT", "funcname")
    WEB_LOG_REQUESTS = to_bool(os.getenv("WEB_LOG_REQUESTS", True))
    WEB_LOG_RESPONSES = to_bool(os.getenv("WEB_LOG_RESPONSES", True))
    WEB_LOG_SAMPLE_FRAC = float(os.getenv("WEB_LOG_SAMPLE_FRAC", 0.5))
    WEB_LOG_SLOW_RESPONSE_THRESHOLD = float(os.getenv("WEB_LOG_SLOW_RESPONSE_THRESHOLD", 3))  # seconds # noqa

    CELERY_LOG_LEVEL = os.getenv("CELERY_LOG_LEVEL", LOG_LEVEL)
    CELERY_LOG_FORMAT = os.getenv("CELERY_LOG_FORMAT", LOG_FORMAT)

    """ --------------- Database --------------- """

    DATABASE_DRIVER = os.getenv("DATABASE_DRIVER", "mongodb")
    DATABASE_USERNAME = os.getenv("DATABASE_USERNAME", None)
    DATABASE_PASSWORD = os.getenv("DATABASE_PASSWORD", None)
    DATABASE_HOST = os.getenv("DATABASE_HOST", "localhost")
    DATABASE_PORT = os.getenv("DATABASE_PORT", 27017)
    DATABASE_NAME = os.getenv("DATABASE_NAME", "default")
    DATABASE_AUTHENTICATION_SOURCE = "admin"
    DATABASE_URI = os.getenv("DATABASE_URI", None)
    REPLICA_SET = os.getenv("REPLICA_SET", None)
    # DATABASE_UUID_REPRESENTATION = "standard"
    # DATABASE_CONNECT = os.getenv("DATABASE_CONNECT", False)

    """ Celery """
    BROKER_URL = os.getenv("CELERY_BROKER_URL", "redis://localhost:6379/0")
    CELERY_TASK_LIST = ["celery_queue.tasks"]
    CELERYD_TASK_TIME_LIMIT = to_int(os.getenv(
        "CELERYD_TASK_TIME_LIMIT", 60 * 60 * 12
    ))  # 12 hours
    CELERY_TASK_SERIALIZER = "json"
    CELERY_ACCEPT_CONTENT = ["json"]
    # CELERYD_MAX_TASKS_PER_CHILD = to_int(os.getenv("CELERYD_MAX_TASKS_PER_CHILD", 1000))
    # CELERYD_MAX_MEMORY_PER_CHILD = to_int(os.getenv("CELERYD_MAX_MEMORY_PER_CHILD", 250000))  # 250MB # noqa
    CELERY_ENABLE_REMOTE_CONTROL = False  # required for sqs
    CELERY_SEND_EVENTS = False  # required for sqs
    CELERY_DEFAULT_QUEUE = f"{project}-default"  # sqs queue name
    CELERY_ROUTES = ("celery_queue.routers.hole_direction_router",)
    CELERY_TASK_CREATE_MISSING_QUEUES = to_bool(os.getenv(
        "CELERY_TASK_CREATE_MISSING_QUEUES", False
    ))
    CELERY_TASK_ALWAYS_EAGER = to_bool(os.getenv("CELERY_TASK_ALWAYS_EAGER", False))

    """ Celery Beat """
    CELERYBEAT_SCHEDULER = "redbeat.RedBeatScheduler"
    CELERYBEAT_LOAD_ENDPOINTS: bool = to_bool(os.getenv("CELERYBEAT_LOAD_ENDPOINTS", True))
    CELERYBEAT_MAX_LOOP_INTERVAL: int = to_int(os.getenv("CELERYBEAT_MAX_LOOP_INTERVAL", 30))
    REDBEAT_REDIS_URL = os.getenv("IHS_CRON_URL")
    REDBEAT_KEY_PREFIX = f"{project}:"
    REDBEAT_LOCK_TIMEOUT = CELERYBEAT_MAX_LOOP_INTERVAL * 5

    """ API """
    API_CLIENT_TYPE = os.getenv("IHS_CLIENT_TYPE", "legacy")
    API_BASE_URL = os.getenv("IHS_URL")
    API_USERNAME = os.getenv("IHS_USERNAME")
    API_PASSWORD = os.getenv("IHS_PASSWORD")
    API_APP_KEY = os.getenv("IHS_APP_KEY")
    API_SYNC_WINDOW_MINUTES = os.getenv("IHS_SYNC_WINDOW_MINUTES", 1440 * 7)
    API_HEADERS = {
        "Username": API_USERNAME,
        "Password": API_PASSWORD,
        "Application": API_APP_KEY,
    }
    API_WSDL_DIR = abs_path(CONFIG_BASEPATH, "wsdl")
    API_WSDLS = {
        "session": abs_path(API_WSDL_DIR, "{version}/Session.wsdl"),
        "querybuilder": abs_path(API_WSDL_DIR, "{version}/QueryBuilder.wsdl"),
        "exportbuilder": abs_path(API_WSDL_DIR, "{version}/ExportBuilder.wsdl"),
    }
    API_DOMAIN = "US"
    TASK_BATCH_SIZE = to_int(os.getenv("IHS_TASK_BATCH_SIZE", 50))
    SIMULATE_EXPENSIVE_TASKS = to_bool(os.getenv("IHS_SIMULATE_EXPENSIVE_TASKS", False))

    @property
    def show(self):
        return [x for x in dir(self) if not x.startswith("_")]

    @property
    def api_params(self):
        return {
            key.lower().replace("api_", ""): getattr(self, key)
            for key in dir(self)
            if key.startswith("API_")
        }

    @property
    def datadog_params(self):
        return {
            key.lower().replace("datadog_", ""): getattr(self, key)
            for key in dir(self)
            if key.startswith("DATADOG_")
        }

    @property
    def sentry_params(self):
        return {
            key.lower().replace("sentry_", ""): getattr(self, key)
            for key in dir(self)
            if key.startswith("SENTRY_")
        }

    @property
    def endpoints(self):
        return self.COLLECTOR_CONFIG.endpoints

    @property
    def functions(self):
        return self.COLLECTOR_CONFIG.functions

    @property
    def database_params(self):
        return {
            key.lower().replace("database_", ""): getattr(self, key)
            for key in dir(self)
            if key.startswith("DATABASE_")
        }

    def database_uri(self, hide_password=False, include_auth_source=True):
        db = self.database_params
        username = db.get("username")
        password = "******" if hide_password else db.get("password")
        auth_source = (
            f"?authSource={db.get('authentication_source')}"
            if include_auth_source
            else ""
        )
        if self.REPLICA_SET:
            replica_set = (
                f"?replicaSet={self.REPLICA_SET}"
                if not auth_source
                else f"&replicaSet={self.REPLICA_SET}"
            )
        else:
            replica_set = ""

        driver = db.get("driver", "")
        host = db.get("host", "")
        port = db.get("port", "")
        dbname = db.get("name", "")
        at = "@" if username else ""
        colon = ":" if username is not None else ""
        username = username or ""
        password = password or ""
        return f"{driver}://{username}{colon}{password}{at}{host}:{port}/{dbname}{auth_source}{replica_set}"  # noqa

    def __repr__(self):
        """ Print configuration summary """
        hr = "-" * shutil.get_terminal_size().columns + "\n"
        tpl = "{name:>25} {value:<50}\n"
        string = ""
        string += tpl.format(name="app config:", value=APP_SETTINGS)
        string += tpl.format(name="flask app:", value=FLASK_APP)
        string += tpl.format(name="flask env:", value=self.FLASK_ENV)
        string += tpl.format(
            name="backend:",
            value=self.database_uri(hide_password=True, include_auth_source=False),
        )
        string += tpl.format(name="broker:", value=self.BROKER_URL)
        # string += tpl.format(name="result broker:", value=self.CELERY_RESULT_BACKEND)
        string += tpl.format(name="collector:", value=self.API_BASE_URL)
        return hr + string + hr