Beispiel #1
0
    def test_fetch_with_data(self):
        create(self.SIMPLE_CREATE_ARGS)
        update_start = time_ref + 1
        for ts in range(update_start, update_start + 300, 10):
            update('/tmp/foo', '%i:100:200' % ts)

        ret = fetch(
            '/tmp/foo',
            'AVERAGE',
            '-s %i' % time_ref,
            '-e %i' % (time_ref + 400)
        )

        ref = (
            (1368278970, 1368279380, 10),
            (six.u('a'), six.u('b')),
            [
                (None, None), (100.0, 200.0), (100.0, 200.0), (100.0, 200.0),
                (100.0, 200.0), (100.0, 200.0), (100.0, 200.0), (100.0, 200.0),
                (100.0, 200.0), (100.0, 200.0), (100.0, 200.0), (100.0, 200.0),
                (100.0, 200.0), (100.0, 200.0), (100.0, 200.0), (100.0, 200.0),
                (100.0, 200.0), (100.0, 200.0), (100.0, 200.0), (100.0, 200.0),
                (100.0, 200.0), (100.0, 200.0), (100.0, 200.0), (100.0, 200.0),
                (100.0, 200.0), (100.0, 200.0), (100.0, 200.0), (100.0, 200.0),
                (100.0, 200.0), (100.0, 200.0), (None, None), (None, None),
                (None, None), (None, None), (None, None), (None, None),
                (None, None), (None, None), (None, None), (None, None),
                (None, None)
            ]
        )
        self.assertEqual(ref, ret)
    def test__gather_files(self, path_mock, os_mock):
        """ Tests the _gather_files function """
        self.app.static_folder = '/home'
        self.app.static_url_path = '/static'

        bp_a = Mock(static_folder='/home/bar', static_url_path='/a/bar',
                    url_prefix=None)
        bp_b = Mock(static_folder='/home/zoo', static_url_path='/b/bar',
                    url_prefix=None)
        bp_c = Mock(static_folder=None)

        self.app.blueprints = {'a': bp_a, 'b': bp_b, 'c': bp_c}
        dirs = {'/home': [('/home', None, ['.a'])],
                '/home/bar': [('/home/bar', None, ['b'])],
                '/home/zoo': [('/home/zoo', None, ['c']),
                              ('/home/zoo/foo', None, ['d', 'e'])]}
        os_mock.side_effect = dirs.get
        path_mock.return_value = True

        expected = {('/home/bar', six.u('/a/bar')): ['/home/bar/b'],
                    ('/home/zoo', six.u('/b/bar')): ['/home/zoo/c',
                                               '/home/zoo/foo/d',
                                               '/home/zoo/foo/e']}
        actual = flask_s3._gather_files(self.app, False)
        self.assertEqual(expected, actual)

        expected[('/home', six.u('/static'))] = ['/home/.a']
        actual = flask_s3._gather_files(self.app, True)
        self.assertEqual(expected, actual)
    def test_find_archive_with_unknown_properties(self):
        archive_id = u('f6e7ee58-d6cf-4a59-896b-6d56b158ec71')
        httpretty.register_uri(httpretty.GET, u('https://api.opentok.com/v2/partner/{0}/archive/{1}').format(self.api_key, archive_id),
                               body=textwrap.dedent(u("""\
                                       {
                                          "createdAt" : 1395187836000,
                                          "duration" : 62,
                                          "id" : "f6e7ee58-d6cf-4a59-896b-6d56b158ec71",
                                          "name" : "",
                                          "partnerId" : 123456,
                                          "reason" : "",
                                          "sessionId" : "SESSIONID",
                                          "size" : 8347554,
                                          "status" : "expired",
                                          "url" : null,
                                          "hasAudio": true,
                                          "hasVideo": true,
                                          "notarealproperty" : "not a real value"
                                        }""")),
                               status=200,
                               content_type=u('application/json'))

        archive = self.opentok.get_archive(archive_id)

        expect(archive).to.be.an(Archive)
Beispiel #4
0
def frozenset_string(value, seen):
    if value:
        return u('frozenset({%s})') % (u(', ').join(sorted(
            show(c, seen) for c in value
        )))
    else:
        return repr(value)
 def test_non_bytes(self):
     padder = padding.PKCS7(128).padder()
     with pytest.raises(TypeError):
         padder.update(six.u("abc"))
     unpadder = padding.PKCS7(128).unpadder()
     with pytest.raises(TypeError):
         unpadder.update(six.u("abc"))
Beispiel #6
0
def sanitize(input, cleaner=DocumentCleaner, wrap='p'):
    """Cleanup markup using a given cleanup configuration.
       Unwrapped text will be wrapped with wrap parameter.
    """
    if 'body' not in cleaner.allow_tags:
        cleaner.allow_tags.append('body')

    input = six.u("<html><body>%s</body></html>") % input
    document = html.document_fromstring(input)
    bodies = [e for e in document if html._nons(e.tag) == 'body']
    body = bodies[0]

    cleaned = cleaner.clean_html(body)
    remove_empty_tags(cleaned)
    strip_outer_breaks(cleaned)

    if wrap is not None:
        if wrap in html.defs.tags:
            wrap_text(cleaned, wrap)
        else:
            raise ValueError(
                'Invalid html tag provided for wrapping the sanitized text')

    output = six.u('').join([etree.tostring(fragment, encoding=six.text_type)
        for fragment in cleaned.iterchildren()])
    if wrap is None and cleaned.text:
        output = cleaned.text + output

    return output
Beispiel #7
0
 def info(self):
     if self.project is not None:
         return six.u("join project '%s'") % self.project.pid
     elif self.name:
         return six.u("create project '%s'") % self.name
     else:
         return six.u("create/join a project")
Beispiel #8
0
    def parseInvstmtrs(cls_, invstmtrs_list):
        ret = []
        for invstmtrs_ofx in invstmtrs_list:
            account = InvestmentAccount()
            acctid_tag = invstmtrs_ofx.find('acctid')
            if (hasattr(acctid_tag, 'contents')):
                try:
                    account.account_id = acctid_tag.contents[0].strip()
                except IndexError:
                    account.warnings.append(
                        six.u("Empty acctid tag for %s") % invstmtrs_ofx)
                    if cls_.fail_fast:
                        raise

            brokerid_tag = invstmtrs_ofx.find('brokerid')
            if (hasattr(brokerid_tag, 'contents')):
                try:
                    account.brokerid = brokerid_tag.contents[0].strip()
                except IndexError:
                    account.warnings.append(
                        six.u("Empty brokerid tag for %s") % invstmtrs_ofx)
                    if cls_.fail_fast:
                        raise

            account.type = AccountType.Investment

            if (invstmtrs_ofx):
                account.statement = cls_.parseInvestmentStatement(
                    invstmtrs_ofx)
            ret.append(account)
        return ret
Beispiel #9
0
 def parseBalance(cls_, statement, stmt_ofx, bal_tag_name, bal_attr, bal_date_attr, bal_type_string):
     bal_tag = stmt_ofx.find(bal_tag_name)
     if hasattr(bal_tag, "contents"):
         balamt_tag = bal_tag.find('balamt')
         dtasof_tag = bal_tag.find('dtasof')
         if hasattr(balamt_tag, "contents"):
             try:
                 setattr(statement, bal_attr, decimal.Decimal(
                     balamt_tag.contents[0].strip()))
             except (IndexError, decimal.InvalidOperation):
                 ex = sys.exc_info()[1]
                 statement.warnings.append(
                     six.u("%s balance amount was empty for %s") % (bal_type_string, stmt_ofx))
                 if cls_.fail_fast:
                     raise OfxParserException("Empty %s balance" % bal_type_string)
         if hasattr(dtasof_tag, "contents"):
             try:
                 setattr(statement, bal_date_attr, cls_.parseOfxDateTime(
                     dtasof_tag.contents[0].strip()))
             except IndexError:
                 statement.warnings.append(
                     six.u("%s balance date was empty for %s") % (bal_type_string, stmt_ofx))
                 if cls_.fail_fast:
                     raise
             except ValueError:
                 statement.warnings.append(
                     six.u("%s balance date was not allowed for %s") % (bal_type_string, stmt_ofx))
                 if cls_.fail_fast:
                     raise
Beispiel #10
0
def test_zero_byte_string():
    # Tests hack to allow chars of non-zero length, but 0 bytes
    # make reader-like thing
    str_io = cStringIO()
    r = _make_readerlike(str_io, boc.native_code)
    c_reader = m5u.VarReader5(r)
    tag_dt = np.dtype([('mdtype', 'u4'), ('byte_count', 'u4')])
    tag = np.zeros((1,), dtype=tag_dt)
    tag['mdtype'] = mio5p.miINT8
    tag['byte_count'] = 1
    hdr = m5u.VarHeader5()
    # Try when string is 1 length
    hdr.set_dims([1,])
    _write_stream(str_io, tag.tostring() + b'        ')
    str_io.seek(0)
    val = c_reader.read_char(hdr)
    assert_equal(val, u(' '))
    # Now when string has 0 bytes 1 length
    tag['byte_count'] = 0
    _write_stream(str_io, tag.tostring())
    str_io.seek(0)
    val = c_reader.read_char(hdr)
    assert_equal(val, u(' '))
    # Now when string has 0 bytes 4 length
    str_io.seek(0)
    hdr.set_dims([4,])
    val = c_reader.read_char(hdr)
    assert_array_equal(val, [u(' ')] * 4)
Beispiel #11
0
def check_username_for_new_account(person, username, machine_category):
    """ Check the new username for a new account. If the username  is
    in use, raises :py:exc:`UsernameTaken`.

    :param person: Owner of new account.
    :param username: Username to validate.
    :param machine_category: Machine category for new account.
    """

    query = Account.objects.filter(
        username__exact=username,
        machine_category=machine_category,
        date_deleted__isnull=True)

    if query.count() > 0:
        raise UsernameTaken(
            six.u('Username already in use on machine category %s.')
            % machine_category)

    if machine_category_account_exists(username, machine_category):
        raise UsernameTaken(
            six.u('Username is already in datastore for machine category %s.')
            % machine_category)

    return username
Beispiel #12
0
def coerce_output(s):
    if isinstance(s, ColoredString):
        return six.u(str(s))
    elif isinstance(s, six.binary_type):
        return six.u(s)
    else:
        return s
Beispiel #13
0
    def _build_illegal_xml_regex():
        """Constructs a regex to match all illegal xml characters.

        Expects to be used against a unicode string."""
        # Construct the range pairs of invalid unicode characters.
        illegal_chars_u = [
            (0x00, 0x08), (0x0B, 0x0C), (0x0E, 0x1F), (0x7F, 0x84),
            (0x86, 0x9F), (0xFDD0, 0xFDDF), (0xFFFE, 0xFFFF)]

        # For wide builds, we have more.
        if sys.maxunicode >= 0x10000:
            illegal_chars_u.extend(
                [(0x1FFFE, 0x1FFFF), (0x2FFFE, 0x2FFFF), (0x3FFFE, 0x3FFFF),
                 (0x4FFFE, 0x4FFFF), (0x5FFFE, 0x5FFFF), (0x6FFFE, 0x6FFFF),
                 (0x7FFFE, 0x7FFFF), (0x8FFFE, 0x8FFFF), (0x9FFFE, 0x9FFFF),
                 (0xAFFFE, 0xAFFFF), (0xBFFFE, 0xBFFFF), (0xCFFFE, 0xCFFFF),
                 (0xDFFFE, 0xDFFFF), (0xEFFFE, 0xEFFFF), (0xFFFFE, 0xFFFFF),
                 (0x10FFFE, 0x10FFFF)])

        # Build up an array of range expressions.
        illegal_ranges = [
            "%s-%s" % (six.unichr(low), six.unichr(high))
            for (low, high) in illegal_chars_u]

        # Compile the regex
        return re.compile(six.u('[%s]') % six.u('').join(illegal_ranges))
 def test_generate_role_token(self):
     session = Session(self.opentok, self.session_id, media_mode=MediaModes.routed, location=None)
     token = session.generate_token(role=Roles.moderator)
     assert isinstance(token, text_type)
     assert token_decoder(token)[u('session_id')] == self.session_id
     assert token_decoder(token)[u('role')] == u('moderator')
     assert token_signature_validator(token, self.api_secret)
Beispiel #15
0
   def __init__(self, authid = None, authrole = None, authmethod = None, authprovider = None):
      """
      Ctor.

      :param authid: The authentication ID the client is assigned, e.g. `"joe"` or `"*****@*****.**"`.
      :type authid: str
      :param authrole: The authentication role the client is assigned, e.g. `"anonymous"`, `"user"` or `"com.myapp.user"`.
      :type authrole: str
      :param authmethod: The authentication method that was used to authenticate the client, e.g. `"cookie"` or `"wampcra"`.
      :type authmethod: str
      :param authprovider: The authentication provider that was used to authenticate the client, e.g. `"mozilla-persona"`.
      :type authprovider: str
      """
      if six.PY2:
         if type(authid) == str:
            authid = six.u(authid)
         if type(authrole) == str:
            authrole = six.u(authrole)
         if type(authmethod) == str:
            authmethod = six.u(authmethod)
         if type(authprovider) == str:
            authprovider = six.u(authprovider)

      assert(authid is None or type(authid) == six.text_type)
      assert(authrole is None or type(authrole) == six.text_type)
      assert(authmethod is None or type(authmethod) == six.text_type)
      assert(authprovider is None or type(authprovider) == six.text_type)

      self.authid = authid
      self.authrole = authrole
      self.authmethod = authmethod
      self.authprovider = authprovider
Beispiel #16
0
def on_search(args):
    # TODO: Decode via actual tty encoding
    try:
        q = args.q[0].decode("utf-8")
    except AttributeError:
        q = args.q[0]
    pkg_names = set()
    # First, check for exact case-insensitive name matches
    for pkg in session.query(Package).filter(collate(Package.name,"NOCASE")==q).all():
        pkg_names.add(pkg.name)
    # Check for substring name matches
    for pkg in session.query(Package).filter(Package.name.like(u('%{0}%').format(q))).all():
        pkg_names.add(pkg.name)
    # Check for description matches
    for pkg in session.query(Package).filter(Package.description.like(u('%{0}%').format(q))).all():
        pkg_names.add(pkg.name)

    if len(pkg_names) == 0:
        print_(u('No matching packages found.'))
        return

    # Nice column formatting
    max_len_name = max( len(name) for name in pkg_names )

    for pkg_name in sorted(pkg_names):
        pkg = session.query(Package).get(pkg_name)
        print_(u('{name:{max_len_name}} {version:10} {desc}'.format(name=pkg.name, version=pkg.version, desc=pkg.description, max_len_name=max_len_name)))
Beispiel #17
0
 def test_unicode_deserialize(self):
     """
     UnicodeAttribute.deserialize
     """
     attr = UnicodeAttribute()
     self.assertEqual(attr.deserialize('foo'), six.u('foo'))
     self.assertEqual(attr.deserialize(u'foo'), six.u('foo'))
Beispiel #18
0
def render_structure(fs_source_root, fs_target_root, variables, verbose, renderer):
    """Recursively copies the given filesystem path `fs_source_root_ to a target directory `fs_target_root`.

    Any files ending in `.bob` are rendered as templates using the given
    renderer using the variables dictionary, thereby losing the `.bob` suffix.

    strings wrapped in `+` signs in file- or directory names will be replaced
    with values from the variables, i.e. a file named `+name+.py.bob` given a
    dictionary {'name': 'bar'} would be rendered as `bar.py`.
    """
    if not isinstance(fs_source_root, six.text_type):  # pragma: no cover
        fs_source_root = six.u(fs_source_root)
    for fs_source_dir, local_directories, local_files in os.walk(fs_source_root):
        fs_target_dir = path.abspath(path.join(fs_target_root, path.relpath(fs_source_dir, fs_source_root)))
        for local_file in local_files:
            if local_file == '.mrbob.ini':
                continue
            render_template(
                path.join(fs_source_dir, local_file),
                render_filename(fs_target_dir, variables),
                variables,
                verbose,
                renderer,
            )
        for local_directory in local_directories:
            abs_dir = render_filename(path.join(fs_target_dir, local_directory), variables)
            if not path.exists(abs_dir):
                if verbose:
                    print(six.u("mkdir %s") % abs_dir)
                os.mkdir(abs_dir)
Beispiel #19
0
def test_print_():
    save = sys.stdout
    out = sys.stdout = six.moves.StringIO()
    try:
        six.print_("Hello,", "person!")
    finally:
        sys.stdout = save
    assert out.getvalue() == "Hello, person!\n"
    out = six.StringIO()
    six.print_("Hello,", "person!", file=out)
    assert out.getvalue() == "Hello, person!\n"
    out = six.StringIO()
    six.print_("Hello,", "person!", file=out, end="")
    assert out.getvalue() == "Hello, person!"
    out = six.StringIO()
    six.print_("Hello,", "person!", file=out, sep="X")
    assert out.getvalue() == "Hello,Xperson!\n"
    out = six.StringIO()
    six.print_(six.u("Hello,"), six.u("person!"), file=out)
    result = out.getvalue()
    assert isinstance(result, six.text_type)
    assert result == six.u("Hello, person!\n")
    six.print_("Hello", file=None) # This works.
    out = six.StringIO()
    six.print_(None, file=out)
    assert out.getvalue() == "None\n"
Beispiel #20
0
def _format_final_exc_line(etype, value):
    valuestr = _some_str(value)
    if value == 'None' or value is None or not valuestr:
        line = u("%s\n") % etype
    else:
        line = u("%s: %s\n") % (etype, valuestr)
    return line
Beispiel #21
0
    def pre_save(cls, self):
        full_name = getattr(self, "fullName", None)
        if full_name is None:
            full_name = "%s %s" % (self.givenName, self.sn)

        self.displayName = six.u('%s (%s)') % (full_name, self.o)
        self.gecos = _a(six.u('%s (%s)') % (full_name, self.o))
Beispiel #22
0
def set_bool(x):
    if isinstance(x, bool):
        return x
    elif isinstance(x, integer_types):
        return x != 0
    else:
        return text_type(x).strip().lower() not in {u('0'), b('0'), u('n'), b('n'), u('no'), b('no'), u('f'), b('f'), u('false'), b('false')}
 def test_encode(self):
     # _encode must encode unicode strings
     self.assertEqual(_encode(six.u('привет')),
                      six.u('привет').encode('utf-8'))
     # _encode must return byte strings unchanged
     self.assertEqual(_encode(six.u('привет').encode('utf-8')),
                      six.u('привет').encode('utf-8'))
Beispiel #24
0
 def test_wrong_encoding(self):
     string = String()
     unknown_char = u("\ufffd") * (2 if six.PY3 else 4)
     self.assert_equal(
         string.decode(u("ündecödäble").encode("utf-8"), "ascii"),
         u("%(u)sndec%(u)sd%(u)sble") % {"u": unknown_char}
     )
 def address(self, qs, out):
     """simple single entry per line in the format of:
         "full name" <*****@*****.**>;
     """
     out.write(six.u("\n").join(six.u('"%s" <%s>;' % (full_name(**ent), ent['email']))
                                for ent in qs).encode(self.encoding))
     out.write("\n")
Beispiel #26
0
 def test_unicode_password(self):
     j = jenkins.Jenkins('{0}'.format(self.base_url),
                         six.u('nonascii'),
                         six.u('\xe9\u20ac'))
     self.assertEqual(j.server, self.make_url(''))
     self.assertEqual(j.auth, b'Basic bm9uYXNjaWk6w6nigqw=')
     self.assertEqual(j.crumb, None)
Beispiel #27
0
    def load(self, name, package=__package__):
        if name in self.plugins:
            msg = u("Not loading already loaded plugin: {0}").format(name)
            self.logger.warn(msg)
            return msg

        try:
            fqplugin = "{0}.{1}".format(package, name)
            if fqplugin in sys.modules:
                reload(sys.modules[fqplugin])

            m = safe__import__(name, globals(), locals(), package)

            p1 = lambda x: isclass(x) and issubclass(x, BasePlugin)  # noqa
            p2 = lambda x: x is not BasePlugin  # noqa
            predicate = lambda x: p1(x) and p2(x)  # noqa
            plugins = getmembers(m, predicate)

            for name, Plugin in plugins:
                instance = Plugin(*self.init_args, **self.init_kwargs)
                instance.register(self)
                self.logger.debug(u("Registered Component: {0}").format(instance))
                if name not in self.plugins:
                    self.plugins[name] = set()
                self.plugins[name].add(instance)

            msg = u("Loaded plugin: {0}").format(name)
            self.logger.info(msg)
            return msg
        except Exception, e:
            msg = u("Could not load plugin: {0} Error: {1}").format(name, e)
            self.logger.error(msg)
            self.logger.error(format_exc())
            return msg
Beispiel #28
0
 def test_unicode_names(self):
     """ Unicode field names for for read and write """
     self.assertArrayEqual(self.dset[six.u('a')], self.data['a'])
     self.dset[six.u('a')] = 42
     data = self.data.copy()
     data['a'] = 42
     self.assertArrayEqual(self.dset[six.u('a')], data['a'])
Beispiel #29
0
    def __init__(self, zone, vrf, network, template,
                 params=None, loader=None):

        try:
            self.network = IPv4Network(u(str(network)))
            self.ipversion = 4
        except AddressValueError:
            try:
                self.network = IPv6Network(u(str(network)))
                self.ipversion = 6
            except AddressValueError:
                raise ConfigError('invalid network: {}'.format(str(network)))

        if loader is None:
            loader = FileSystemLoader('templates')
        env = Environment(loader=loader,
                          extensions=['jinja2.ext.do',
                                      'jinja2.ext.loopcontrols'])
        add_custom_filters(env)
        add_custom_globals(env, self.ipversion)
        self.template = env.get_template('{0}.yaml'.format(template))
        self.zone = zone
        self.vrf = vrf
        self.params = 0
        self.params = params if params is not None else {}
        self._rendered = None
        self._data = None
Beispiel #30
0
    def remove_objects_not_in(self, objects_to_keep, verbosity):
        """
        Deletes all the objects in the database that are not in objects_to_keep.
        - objects_to_keep: A map where the keys are classes, and the values are a
         set of the objects of that class we should keep.
        """
        for class_ in objects_to_keep.keys():
            current = class_.objects.all()
            current_ids = set([x.pk for x in current])
            keep_ids = set([x.pk for x in objects_to_keep[class_]])

            remove_these_ones = current_ids.difference(keep_ids)
            if remove_these_ones:
                for obj in current:
                    if obj.pk in remove_these_ones:
                        obj.delete()
                        if verbosity >= 2:
                            print("Deleted object: %s" % six.u(obj))

            if verbosity > 0 and remove_these_ones:
                num_deleted = len(remove_these_ones)
                if num_deleted > 1:
                    type_deleted = six.u(class_._meta.verbose_name_plural)
                else:
                    type_deleted = six.u(class_._meta.verbose_name)

                print("Deleted %s %s" % (str(num_deleted), type_deleted))
Beispiel #31
0
    def start_archive(self,
                      session_id,
                      has_audio=True,
                      has_video=True,
                      name=None,
                      output_mode=OutputModes.composed):
        """
        Starts archiving an OpenTok session.

        Clients must be actively connected to the OpenTok session for you to successfully start
        recording an archive.

        You can only record one archive at a time for a given session. You can only record archives
        of sessions that use the OpenTok Media Router (sessions with the media mode set to routed);
        you cannot archive sessions with the media mode set to relayed.

        For more information on archiving, see the
        `OpenTok archiving <https://tokbox.com/opentok/tutorials/archiving/>`_ programming guide.

        :param String session_id: The session ID of the OpenTok session to archive.
        :param String name: This is the name of the archive. You can use this name
          to identify the archive. It is a property of the Archive object, and it is a property
          of archive-related events in the OpenTok.js library.
        :param Boolean has_audio: if set to True, an audio track will be inserted to the archive.
          has_audio is an optional parameter that is set to True by default. If you set both
          has_audio and has_video to False, the call to the start_archive() method results in
          an error.
        :param Boolean has_video: if set to True, a video track will be inserted to the archive.
          has_video is an optional parameter that is set to True by default.
        :param OutputModes output_mode: Whether all streams in the archive are recorded
          to a single file (OutputModes.composed, the default) or to individual files
          (OutputModes.individual).

        :rtype: The Archive object, which includes properties defining the archive,
          including the archive ID.
        """
        if not isinstance(output_mode, OutputModes):
            raise OpenTokException(
                u('Cannot start archive, {0} is not a valid output mode').
                format(output_mode))

        payload = {
            'name': name,
            'sessionId': session_id,
            'hasAudio': has_audio,
            'hasVideo': has_video,
            'outputMode': output_mode.value
        }

        response = requests.post(self.archive_url(),
                                 data=json.dumps(payload),
                                 headers=self.archive_headers(),
                                 proxies=self.proxies)

        if response.status_code < 300:
            return Archive(self, response.json())
        elif response.status_code == 403:
            raise AuthError()
        elif response.status_code == 400:
            raise RequestError("Session ID is invalid")
        elif response.status_code == 404:
            raise NotFoundError("Session not found")
        elif response.status_code == 409:
            raise ArchiveError(response.json().get("message"))
        else:
            raise RequestError("An unexpected error occurred",
                               response.status_code)
Beispiel #32
0
class TestRequest:
    @pytest.mark.parametrize("message",
                             (None, "it's hard out here...",
                              u("\u57CE\u697C\u4E07\u4F17\u68C0\u9605")))
    def test_construct(self, message):
        # Always use the same URL as different ways to specify a Request's URL
        # are tested separately.
        url = "some://url"
        timeout = 10
        request = Request(url, message, timeout)
        assert request.url is url
        assert request.message is message
        assert request.headers == {}
        assert request.timeout == timeout

    def test_construct_with_no_message(self):
        request = Request("some://url")
        assert request.headers == {}
        assert request.message is None

    test_non_ASCII_URLs = [
        u("\u4E2D\u539F\u5343\u519B\u9010\u848B"),
        u("\u57CE\u697C\u4E07\u4F17\u68C0\u9605")
    ] + [
        url_prefix + url_suffix for url_prefix in (u(""), u("Jurko"))
        for url_suffix in (unichr(128), unichr(200), unichr(1000))
    ]

    @pytest.mark.parametrize(
        "url",
        test_non_ASCII_URLs +  # unicode strings
        [x.encode("utf-8") for x in test_non_ASCII_URLs])  # byte strings
    def test_non_ASCII_URL(self, url):
        """Transport Request should reject URLs with non-ASCII characters."""
        pytest.raises(UnicodeError, Request, url)

    @pytest.mark.parametrize(
        ("url", "headers", "message"),
        (("my URL", {}, ""), ("", {
            "aaa": "uf-uf"
        }, "for a bitch it's haaaard..."),
         ("http://rumple-fif/muka-laka-hiki", {
             "uno": "eins",
             "zwei": "due"
         }, """\
I'm here to kick ass,
and chew bubble gum...
and I'm all out of gum."""),
         ("", {},
          u("\u0161u\u0107-mu\u0107 pa o\u017Ee\u017Ei.. za 100 "
            "\u20AC\n\nwith multiple\nlines...")), ("", {}, "\n\n\n\n\n\n"),
         ("", {}, u("\u4E2D\u539F\u5343\u519B\u9010\u848B"))))
    def test_string_representation_with_message(self, url, headers, message):
        for key, value in list(headers.items()):
            old_key = key
            if isinstance(key, text_type):
                key = key.encode("utf-8")
                del headers[old_key]
            if isinstance(value, text_type):
                value = value.encode("utf-8")
            headers[key] = value
        if isinstance(message, text_type):
            message = message.encode("utf-8")
        request = Request(url, message)
        request.headers = headers
        expected = u("""\
URL: %s
HEADERS: %s
MESSAGE:
%s""") % (url, request.headers, message.decode("raw_unicode_escape"))
        assert text_type(request) == expected
        if sys.version_info < (3, ):
            assert str(request) == expected.encode("utf-8")

    def test_string_representation_with_no_message(self):
        url = "look at my silly little URL"
        headers = {suds.byte_str("yuck"): suds.byte_str("ptooiii...")}
        request = Request(url)
        request.headers = headers
        expected = u("""\
URL: %s
HEADERS: %s""") % (url, request.headers)
        assert text_type(request) == expected
        if sys.version_info < (3, ):
            assert str(request) == expected.encode("utf-8")

    test_URLs = [
        u(""),
        u("http://host/path/name"),
        u("cogito://ergo/sum"),
        u("haleluya"),
        u("look  at  me flyyyyyyyy"),
        unichr(127),
        u("Jurko") + unichr(127)
    ]

    @pytest.mark.parametrize("url", test_URLs +
                             [url.encode("ascii") for url in test_URLs])
    def test_URL(self, url):
        """
        Transport Request accepts its URL as either a byte or a unicode string.

        Internally URL information is kept as the native Python str type.

        """
        request = Request(url)
        assert isinstance(request.url, str)
        if url.__class__ is str:
            assert request.url is url
        elif url.__class__ is u:
            assert request.url == url.encode("ascii")  # Python 2.
        else:
            assert request.url == url.decode("ascii")  # Python 3.

    test_URLs = [unichr(0), u("Jurko") +
                 unichr(0)] if sys.version_info <= (3, 6) else [
                 ]  # "https://bugs.python.org/issue32745"

    @pytest.mark.parametrize("url", test_URLs +
                             [url.encode("ascii") for url in test_URLs])
    def test_URL_null_bytes(self, url):
        """
        Transport Request accepts its URL as either a byte or a unicode string.

        Internally URL information is kept as the native Python str type.

        """
        request = Request(url)
        assert isinstance(request.url, str)
        if url.__class__ is str:
            assert request.url is url
        elif url.__class__ is u:
            assert request.url == url.encode("ascii")  # Python 2.
        else:
            assert request.url == url.decode("ascii")  # Python 3.
Beispiel #33
0
def paper_to_quickstatements(paper):
    """Convert paper to Quickstatements.

    Convert a paper represented as a dict in to Magnus Manske's
    Quickstatement format for entry into Wikidata.

    Parameters
    ----------
    paper : dict
        Scraped paper represented as a dict.

    Returns
    -------
    qs : str
        Quickstatements as a string

    References
    ----------
    https://quickstatements.toolforge.org

    Notes
    -----
    title, authors (list), date, doi, year, language_q, volume, issue, pages,
    number_of_pages, url, full_text_url, published_in_q are recognized.

    `date` takes precedence over `year`.

    """
    qs = u("CREATE\n")

    title = escape_string(paper['title'])
    qs += u('LAST\tLen\t"{}"\n').format(title)

    # Instance of scientific article
    qs += 'LAST\tP31\tQ13442814\n'

    # Title
    qs += u('LAST\tP1476\ten:"{}"\n').format(title)

    # DOI
    if 'doi' in paper:
        qs += u('LAST\tP356\t"{}"\n').format(escape_string(paper['doi']))

    # Authors
    for n, author in enumerate(paper['authors'], start=1):
        qs += u('LAST\tP2093\t"{}"\tP1545\t"{}"\n').format(author, n)

    # Published in
    if 'date' in paper:
        # Day precision
        qs += 'LAST\tP577\t+{}T00:00:00Z/11\n'.format(paper['date'])
    elif 'year' in paper:
        # Year precision
        qs += 'LAST\tP577\t+{}-01-01T00:00:00Z/9\n'.format(paper['year'])

    # Volume
    if 'volume' in paper:
        qs += u('LAST\tP478\t"{}"\n').format(escape_string(paper['volume']))

    # Issue
    if 'issue' in paper:
        qs += u('LAST\tP433\t"{}"\n').format(escape_string(paper['issue']))

    if 'pages' in paper:
        qs += u('LAST\tP304\t"{}"\n').format(escape_string(paper['pages']))

    if 'number_of_pages' in paper:
        qs += u('LAST\tP1104\t{}\n').format(paper['number_of_pages'])

    # Language
    if 'language_q' in paper:
        qs += 'LAST\tP407\t{}\n'.format(paper['language_q'])

    # Homepage
    if 'url' in paper:
        qs += 'LAST\tP856\t"{}"\n'.format(paper['url'])

    # Fulltext URL
    if 'full_text_url' in paper:
        qs += 'LAST\tP953\t"{}"\n'.format(paper['full_text_url'])

    # Published in
    if 'published_in_q' in paper and paper['published_in_q']:
        qs += 'LAST\tP1433\t{}\n'.format(paper['published_in_q'])

    return qs
Beispiel #34
0
 def __repr__(self):
     return six.u('AttrDict({contents})').format(
         contents=super(AttrDict, self).__repr__())
Beispiel #35
0
import requests

from ..qs import paper_to_quickstatements
from ..query import iso639_to_q, issn_to_qs
from ..utils import escape_string


USER_AGENT = 'Scholia'

HEADERS = {'User-Agent': USER_AGENT}

PAPER_TO_Q_QUERY = u("""
SELECT ?paper WHERE {{
  OPTIONAL {{ ?label rdfs:label "{label}"@en . }}
  OPTIONAL {{ ?title wdt:P1476 "{title}"@en . }}
  OPTIONAL {{ ?url wdt:P953 <{url}> . }}
  BIND(COALESCE(?full_text_url, ?url, ?label, ?title) AS ?paper)
}}
""")

# SPARQL Endpoint for Wikidata Query Service
WDQS_URL = 'https://query.wikidata.org/sparql'


def paper_to_q(paper):
    """Find Q identifier for paper.

    Parameters
    ----------
    paper : dict
        Paper represented as dictionary.
Beispiel #36
0
    def generate_token(self,
                       session_id,
                       role=Roles.publisher,
                       expire_time=None,
                       data=None,
                       initial_layout_class_list=[]):
        """
        Generates a token for a given session.

        :param String session_id: The session ID of the session to be accessed by the client using
          the token.

        :param String role: The role for the token. Valid values are defined in the Role
          class:

          * `Roles.subscriber` -- A subscriber can only subscribe to streams.

          * `Roles.publisher` -- A publisher can publish streams, subscribe to
            streams, and signal. (This is the default value if you do not specify a role.)

          * `Roles.moderator` -- In addition to the privileges granted to a
            publisher, in clients using the OpenTok.js 2.2 library, a moderator can call the
            `forceUnpublish()` and `forceDisconnect()` method of the
            Session object.

        :param int expire_time: The expiration time of the token, in seconds since the UNIX epoch.
          The maximum expiration time is 30 days after the creation time. The default expiration
          time is 24 hours after the token creation time.

        :param String data: A string containing connection metadata describing the
          end-user. For example, you can pass the user ID, name, or other data describing the
          end-user. The length of the string is limited to 1000 characters. This data cannot be
          updated once it is set.

        :param list initial_layout_class_list: An array of class names (strings)
          to be used as the initial layout classes for streams published by the client. Layout
          classes are used in customizing the layout of videos in
          `live streaming broadcasts <https://tokbox.com/developer/guides/broadcast/#live-streaming>`_ and
          `composed archives <https://tokbox.com/developer/guides/archiving/layout-control.html>`_

        :rtype:
          The token string.
        """

        # normalize
        # expire_time can be an integer, a datetime object, or anything else that can be coerced into an integer
        # after this block it will only be an integer
        if expire_time is not None:
            if isinstance(expire_time, datetime):
                expire_time = calendar.timegm(expire_time.utctimetuple())
            else:
                try:
                    expire_time = int(expire_time)
                except (ValueError, TypeError):
                    raise OpenTokException(
                        u('Cannot generate token, invalid expire time {0}').
                        format(expire_time))
        else:
            expire_time = int(time.time()) + (60 * 60 * 24)  # 1 day

        # validations
        if not text_type(session_id):
            raise OpenTokException(
                u('Cannot generate token, session_id was not valid {0}').
                format(session_id))
        if not isinstance(role, Roles):
            raise OpenTokException(
                u('Cannot generate token, {0} is not a valid role').format(
                    role))
        now = int(time.time())
        if expire_time < now:
            raise OpenTokException(
                u('Cannot generate token, expire_time is not in the future {0}'
                  ).format(expire_time))
        if expire_time > now + (60 * 60 * 24 * 30):  # 30 days
            raise OpenTokException(
                u('Cannot generate token, expire_time is not in the next 30 days {0}'
                  ).format(expire_time))
        if data and len(data) > 1000:
            raise OpenTokException(
                u('Cannot generate token, data must be less than 1000 characters'
                  ))
        if initial_layout_class_list and not all(
                text_type(c) for c in initial_layout_class_list):
            raise OpenTokException(
                u('Cannot generate token, all items in initial_layout_class_list must be strings'
                  ))
        initial_layout_class_list_serialized = u(' ').join(
            initial_layout_class_list)
        if len(initial_layout_class_list_serialized) > 1000:
            raise OpenTokException(
                u('Cannot generate token, initial_layout_class_list must be less than 1000 characters'
                  ))

        # decode session id to verify api_key
        sub_session_id = session_id[2:]
        sub_session_id_bytes = sub_session_id.encode('utf-8')
        sub_session_id_bytes_padded = sub_session_id_bytes + (
            b('=') * (-len(sub_session_id_bytes) % 4))
        try:
            decoded_session_id = base64.b64decode(sub_session_id_bytes_padded,
                                                  b('-_'))
            parts = decoded_session_id.decode('utf-8').split(u('~'))
        except Exception as e:
            raise OpenTokException(
                u('Cannot generate token, the session_id {0} was not valid').
                format(session_id))
        if self.api_key not in parts:
            raise OpenTokException(
                u('Cannot generate token, the session_id {0} does not belong to the api_key {1}'
                  ).format(session_id, self.api_key))

        data_params = dict(
            session_id=session_id,
            create_time=now,
            expire_time=expire_time,
            role=role.value,
            nonce=random.randint(0, 999999),
            initial_layout_class_list=initial_layout_class_list_serialized)
        if data:
            data_params['connection_data'] = data
        data_string = urlencode(data_params, True)

        sig = self._sign_string(data_string, self.api_secret)
        decoded_base64_bytes = u(
            'partner_id={api_key}&sig={sig}:{payload}').format(
                api_key=self.api_key, sig=sig, payload=data_string)
        if PY3:
            decoded_base64_bytes = decoded_base64_bytes.encode('utf-8')
        token = u('{sentinal}{base64_data}').format(
            sentinal=self.TOKEN_SENTINEL,
            base64_data=base64.b64encode(decoded_base64_bytes).decode())
        return token
Beispiel #37
0
class MediaModes(Enum):
    """List of valid settings for the mediaMode parameter of the OpenTok.create_session() method."""
    routed = u('disabled')
    """The session will transmit streams using the OpenTok Media Server."""
    relayed = u('enabled')
    """The session will attempt to transmit streams directly between clients. If two clients
Beispiel #38
0
    def _parse_record(self, raw_record: dict, ipv4: Optional[str], ipv6: Optional[str]) -> List[Record]:
        domain_name = raw_record['domain']
        if not isinstance(domain_name, six.string_types):
            raise TypeError("domain's name must be a string")
        domain_name = domain_name.strip().lower()
        if not domain_name:
            raise ValueError("empty domain name")
        domain = Domain()
        domain.name = domain_name

        record = Record(domain=domain)
        optional_record = None

        tmp = raw_record.get('name')
        if tmp is not None:
            record.name = str(tmp)
            if not record.name:
                raise ValueError("empty record name")

        type_given = False
        if 'type' in raw_record:
            record.type = raw_record['type']
            type_given = True

        target_given = False
        tmp = raw_record.get('target')
        if tmp is not None:
            record.target = str(tmp).strip()
            target_given = True

        if 'ttl' in raw_record:
            record.ttl = raw_record['ttl']

        if target_given and record.target != 'auto':
            try:
                addr = ipaddress.ip_address(six.u(record.target))
            except ValueError:
                pass
            else:
                if isinstance(addr, ipaddress.IPv4Address):
                    if type_given:
                        if record.type == RecordType.AAAA:
                            raise ValueError("cannot use ipv4 for AAAA record")
                    else:
                        record.type = RecordType.A
                elif isinstance(addr, ipaddress.IPv6Address):
                    if type_given:
                        if record.type == RecordType.A:
                            raise ValueError("cannot use ipv6 for A record")
                    else:
                        record.type = RecordType.AAAA
        else:  # target not given or target is 'auto'
            if type_given:
                if record.type == RecordType.AAAA:
                    if not ipv6:
                        raise ValueError("empty ipv6")
                    record.target = ipv6
                elif record.type == RecordType.A:
                    if not ipv4:
                        raise ValueError("empty ipv4")
                    record.target = ipv4
            else:  # type not given
                if not ipv4:
                    raise ValueError("empty ipv4")
                record.type = RecordType.A
                record.target = ipv4
                if ipv6 is not None:
                    optional_record = copy(record)
                    optional_record.type = RecordType.AAAA
                    optional_record.target = ipv6
        return [record] if optional_record is None else [record, optional_record]
def parse(link, data_to_store):
    print link
    resp = requests.get(url=link, cookies={'over18': '1'}, verify=False)
    if resp.status_code != 200:
        print('invalid url:', resp.url)
        return json.dumps({"error": "invalid url"},
                          sort_keys=True,
                          ensure_ascii=False)
    soup = BeautifulSoup(resp.text, 'html.parser')
    main_content = soup.find(id="main-content")
    metas = main_content.select('div.article-metaline')
    author, title, date = '', '', ''
    if metas:
        _author = metas[0].select('span.article-meta-value')[0]
        _title = metas[1].select('span.article-meta-value')[0]
        _date = metas[2].select('span.article-meta-value')[0]
        author = _author.string if _author else author
        title = _title.string if _title else title
        date = _date.string if _date else date

        # remove meta nodes
        for meta in metas:
            meta.extract()
        for meta in main_content.select('div.article-metaline-right'):
            meta.extract()

    # remove and keep push nodes
    pushes = main_content.find_all('div', class_='push')
    for push in pushes:
        push.extract()

    try:
        ip = main_content.find(text=re.compile(u'※ 發信站:'))
        ip = re.search('[0-9]*\.[0-9]*\.[0-9]*\.[0-9]*', ip).group()
    except:
        ip = ""

    filtered = [
        v for v in main_content.stripped_strings
        if v[0] not in [u'※', u'◆'] and v[:2] not in [u'--']
    ]
    expr = re.compile(
        u(r'[^\u4e00-\u9fa5\u3002\uff1b\uff0c\uff1a\u201c\u201d\uff08\uff09\u3001\uff1f\u300a\u300b\s\w:/-_.?~%()]'
          ))
    for i in range(len(filtered)):
        filtered[i] = re.sub(expr, '', filtered[i])

    filtered = [_f for _f in filtered if _f]  # remove empty strings
    content = ' '.join(filtered)
    content = re.sub(r'(\s)+', ' ', content)
    messages = []
    for push in pushes:
        if not push.find('span', 'push-tag'):
            continue
        push_userid = push.find('span', 'push-userid').string.strip(' \t\n\r')
        # if find is None: find().strings -> list -> ' '.join; else the current way
        push_content = push.find('span', 'push-content').strings
        push_content = ' '.join(push_content)[1:].strip(
            ' \t\n\r')  # remove ':'
        push_ipdatetime = push.find('span',
                                    'push-ipdatetime').string.strip(' \t\n\r')
        messages.append(push_userid + ":" + push_content)

    data = {
        'title': title,
        'link': link,
        'author': author,
        'date': date,
        'content': content,
        'ip': ip,
        'messages': " ".join(messages)
    }
    data_to_store.append(
        json.dumps(data, sort_keys=False, ensure_ascii=False) + ",")
Beispiel #40
0
    def create_session(self,
                       location=None,
                       media_mode=MediaModes.relayed,
                       archive_mode=ArchiveModes.manual):
        """
        Creates a new OpenTok session and returns the session ID, which uniquely identifies
        the session.

        For example, when using the OpenTok JavaScript library, use the session ID when calling the
        OT.initSession() method (to initialize an OpenTok session).

        OpenTok sessions do not expire. However, authentication tokens do expire (see the
        generateToken() method). Also note that sessions cannot explicitly be destroyed.

        A session ID string can be up to 255 characters long.

        Calling this method results in an OpenTokException in the event of an error.
        Check the error message for details.

        You can also create a session using the OpenTok
        `REST API <https://tokbox.com/opentok/api/#session_id_production>`_ or
        `the OpenTok dashboard <https://dashboard.tokbox.com/projects>`_.

        :param String media_mode: Determines whether the session will transmit streams using the
             OpenTok Media Router (MediaMode.routed) or not (MediaMode.relayed). By default,
             the setting is MediaMode.relayed.

             With the media_mode property set to MediaMode.relayed, the session
             will attempt to transmit streams directly between clients. If clients cannot connect
             due to firewall restrictions, the session uses the OpenTok TURN server to relay
             audio-video streams.

             The `OpenTok Media
             Router <https://tokbox.com/opentok/tutorials/create-session/#media-mode>`_
             provides the following benefits:

               * The OpenTok Media Router can decrease bandwidth usage in multiparty sessions.
                   (When the mediaMode property is set to  MediaMode.relayed, each client must send
                   a separate audio-video stream to each client subscribing to it.)

               * The OpenTok Media Router can improve the quality of the user experience through
                 audio fallback and video recovery (see https://tokbox.com/platform/fallback). With
                 these features, if a client's connectivity degrades to a degree that
                 it does not support video for a stream it's subscribing to, the video is dropped on
                 that client (without affecting other clients), and the client receives audio only.
                 If the client's connectivity improves, the video returns.

               * The OpenTok Media Router supports the archiving feature, which lets
                 you record, save, and retrieve OpenTok sessions (see http://tokbox.com/platform/archiving).

        :param String archive_mode: Whether the session is automatically archived
            (ArchiveModes.always) or not (ArchiveModes.manual). By default,
            the setting is ArchiveModes.manual, and you must call the
            start_archive() method of the OpenTok object to start archiving. To archive the session
            (either automatically or not), you must set the media_mode parameter to
            MediaModes.routed.

        :param String location: An IP address that the OpenTok servers will use to
            situate the session in its global network. If you do not set a location hint,
            the OpenTok servers will be based on the first client connecting to the session.

        :rtype: The Session object. The session_id property of the object is the session ID.
        """

        # build options
        options = {}
        if not isinstance(media_mode, MediaModes):
            raise OpenTokException(
                u('Cannot create session, {0} is not a valid media mode').
                format(role))
        if not isinstance(archive_mode, ArchiveModes):
            raise OpenTokException(
                u('Cannot create session, {0} is not a valid archive mode').
                format(role))
        if archive_mode == ArchiveModes.always and media_mode != MediaModes.routed:
            raise OpenTokException(
                u('A session with always archive mode must also have the routed media mode.'
                  ))
        options[u('p2p.preference')] = media_mode.value
        options[u('archiveMode')] = archive_mode.value
        if location:
            # validate IP address
            try:
                inet_aton(location)
            except:
                raise OpenTokException(
                    u('Cannot create session. Location must be either None or a valid IPv4 address {0}'
                      ).format(location))
            options[u('location')] = location

        try:
            response = requests.post(self.session_url(),
                                     data=options,
                                     headers=self.headers(),
                                     proxies=self.proxies)
            response.encoding = 'utf-8'

            if response.status_code == 403:
                raise AuthError(
                    'Failed to create session, invalid credentials')
            if not response.content:
                raise RequestError()
            dom = xmldom.parseString(response.content)
        except Exception as e:
            raise RequestError('Failed to create session: %s' % str(e))

        try:
            error = dom.getElementsByTagName('error')
            if error:
                error = error[0]
                raise AuthError('Failed to create session (code=%s): %s' %
                                (error.attributes['code'].value,
                                 error.firstChild.attributes['message'].value))

            session_id = dom.getElementsByTagName(
                'session_id')[0].childNodes[0].nodeValue
            return Session(self,
                           session_id,
                           location=location,
                           media_mode=media_mode,
                           archive_mode=archive_mode)
        except Exception as e:
            raise OpenTokException('Failed to generate session: %s' % str(e))
Beispiel #41
0
 def __str__(cls, self):
     return six.u("%s") % (self.displayName or self.cn)
Beispiel #42
0
def clean_pkg_version(version):
    """Uses pip to prepare a package version string, from our internal version."""
    return six.u(pep440_version(str(version).replace("==", "")))
Beispiel #43
0
    def __init__(self, url, key=None, secret=None, timeout=5, context=None):
        """
        Create a new Crossbar.io push client.
        The only mandatory argument is the Push service endpoint of the Crossbar.io
        instance to push to.
        For signed pushes, provide authentication key and secret. If those are not
        given, unsigned pushes are performed.
        :param url: URL of the HTTP bridge of Crossbar.io (e.g. http://example.com:8080/push).
        :type url: str
        :param key: Optional key to use for signing requests.
        :type key: str
        :param secret: When using signed request, the secret corresponding to key.
        :type secret: str
        :param timeout: Timeout for requests.
        :type timeout: int
        :param context: If the HTTP bridge is running on HTTPS (that is securely over TLS),
            then the context provides the SSL settings the client should use (e.g. the
            certificate chain against which to verify the server certificate). This parameter
            is only available on Python 2.7.9+ and Python 3 (otherwise the parameter is silently
            ignored!). See: https://docs.python.org/2/library/ssl.html#ssl.SSLContext
        :type context: obj or None
        """
        if six.PY2:
            if type(url) == str:
                url = six.u(url)
            if type(key) == str:
                key = six.u(key)
            if type(secret) == str:
                secret = six.u(secret)

        assert (type(url) == six.text_type)
        assert ((key and secret) or (not key and not secret))
        assert (key is None or type(key) == six.text_type)
        assert (secret is None or type(secret) == six.text_type)
        assert (type(timeout) == int)
        if _HAS_SSL and _HAS_SSL_CLIENT_CONTEXT:
            assert (context is None or isinstance(context, ssl.SSLContext))

        self._seq = 1
        self._key = key
        self._secret = secret

        self._endpoint = _parse_url(url)
        self._endpoint['headers'] = {
            "Content-type": "application/json",
            "User-agent": "crossbarconnect-python"
        }

        if self._endpoint['secure']:
            if not _HAS_SSL:
                raise Exception(
                    "Bridge URL is using HTTPS, but Python SSL module is missing"
                )
            if _HAS_SSL_CLIENT_CONTEXT:
                self._connection = HTTPSConnection(self._endpoint['host'],
                                                   self._endpoint['port'],
                                                   timeout=timeout,
                                                   context=context)
            else:
                self._connection = HTTPSConnection(self._endpoint['host'],
                                                   self._endpoint['port'],
                                                   timeout=timeout)
        else:
            self._connection = HTTPConnection(self._endpoint['host'],
                                              self._endpoint['port'],
                                              timeout=timeout)
Beispiel #44
0
    def _generate_desired_capabilities(self, testname):
        # Generate desired capabilities object using config settings.
        browser_type = self._config_reader.get(
            WebDriverFactory.BROWSER_TYPE_CONFIG)

        browser_constant_dict = {
            self.HTMLUNIT: DesiredCapabilities.HTMLUNIT,
            self.HTMLUNITWITHJS: DesiredCapabilities.HTMLUNITWITHJS,
            self.ANDROID: DesiredCapabilities.ANDROID,
            self.CHROME: DesiredCapabilities.CHROME,
            self.FIREFOX: DesiredCapabilities.FIREFOX,
            self.INTERNETEXPLORER: DesiredCapabilities.INTERNETEXPLORER,
            self.IPAD: DesiredCapabilities.IPAD,
            self.IPHONE: DesiredCapabilities.IPHONE,
            self.OPERA: DesiredCapabilities.OPERA,
            self.SAFARI: DesiredCapabilities.SAFARI,
            self.PHANTOMJS: DesiredCapabilities.PHANTOMJS,
            self.OTHER: {
                'browserName': ''
            }  # Blank Desired Capabilities.
        }

        try:
            # Get a copy of the desired capabilities object. (to avoid
            # overwriting the global.)
            desired_capabilities = browser_constant_dict[browser_type].copy()
        except KeyError:
            raise TypeError(
                u("Unsupported Browser Type {0}").format(browser_type))

        # Get additional desired properties from config file and add them in.
        other_desired_capabilities = self._config_reader.get(
            WebDriverFactory.DESIRED_CAPABILITIES_CONFIG)

        for prop in other_desired_capabilities:
            value = other_desired_capabilities[prop]

            if type(other_desired_capabilities[prop]) is dict:
                # do some recursive call to flatten this setting.
                self.__flatten_capabilities(desired_capabilities, prop,
                                            other_desired_capabilities[prop])
            else:  # Handle has a single string value.
                if isinstance(value, basestring):
                    desired_capabilities[prop] = value

                # Version is specified as a string, but we'll allow user to use
                # an int for convenience.
                elif prop == "version":
                    desired_capabilities[prop] = str(value)

                else:
                    desired_capabilities[prop] = value

        # Set the test name property if specified in the WTF_TESTNAME var.
        try:
            test_name = self._config_reader.get("TESTNAME")
            desired_capabilities['name'] = test_name
        except KeyError:
            pass  # No test name is specified, use the default.

        # If there is desired capabilities properties specified in the OS ENV vars,
        # override the desired capabilities value with those values.
        for key in self._env_vars.keys():
            if key.startswith(self.DESIRED_CAPABILITIES_ENV_PREFIX):
                dc_key = key[len(self.DESIRED_CAPABILITIES_ENV_PREFIX):]
                desired_capabilities[dc_key] = self._env_vars[key]

        # Append optional testname postfix if supplied.
        if testname:
            if desired_capabilities['name']:
                desired_capabilities['name'] += "-" + testname
            else:
                # handle case where name is not specified.
                desired_capabilities['name'] = testname

        return desired_capabilities
Beispiel #45
0
 def escape(t):
     return t.replace(u'"""', six.u(r'\"\"\"'))
Beispiel #46
0
#Other non-characters which are not strictly forbidden but
#discouraged.
RESTRICTED_RANGES = [(0x7F, 0x84), (0x86, 0x9F), (0xFDD0, 0xFDDF)]
#check for a wide build
if sys.maxunicode > 0xFFFF:
    RESTRICTED_RANGES += [(0x1FFFE, 0x1FFFF), (0x2FFFE, 0x2FFFF),
                          (0x3FFFE, 0x3FFFF), (0x4FFFE, 0x4FFFF),
                          (0x5FFFE, 0x5FFFF), (0x6FFFE, 0x6FFFF),
                          (0x7FFFE, 0x7FFFF), (0x8FFFE, 0x8FFFF),
                          (0x9FFFE, 0x9FFFF), (0xAFFFE, 0xAFFFF),
                          (0xBFFFE, 0xBFFFF), (0xCFFFE, 0xCFFFF),
                          (0xDFFFE, 0xDFFFF), (0xEFFFE, 0xEFFFF),
                          (0xFFFFE, 0xFFFFF), (0x10FFFE, 0x10FFFF)]

ILLEGAL_REGEX_STR = \
    six.u('[') + \
    six.u('').join(["%s-%s" % (_unichr(l), _unichr(h))
                   for (l, h) in ILLEGAL_RANGES]) + \
    six.u(']')
RESTRICTED_REGEX_STR = \
    six.u('[') + \
    six.u('').join(["%s-%s" % (_unichr(l), _unichr(h))
                   for (l, h) in RESTRICTED_RANGES]) + \
    six.u(']')

_ILLEGAL_REGEX = re.compile(ILLEGAL_REGEX_STR, re.U)
_RESTRICTED_REGEX = re.compile(RESTRICTED_REGEX_STR, re.U)


def string_cleanup(string, keep_restricted=False):
Beispiel #47
0
 def rewrite_standard_width(cls, s):
     return six.u('').join([cls.full_width_digit_map.get(c, c) for c in s])
Beispiel #48
0
    def publish(self, topic, *args, **kwargs):
        """
        Publish an event to subscribers on specified topic via Crossbar.io HTTP bridge.
        The event payload (positional and keyword) can be of any type that can be
        serialized to JSON.
        If `kwargs` contains an `options` attribute, this is expected to
        be a dictionary with the following possible parameters:
         * `exclude`: A list of WAMP session IDs to exclude from receivers.
         * `eligible`: A list of WAMP session IDs eligible as receivers.
        :param topic: Topic to push to.
        :type topic: str
        :param args: Arbitrary application payload for the event (positional arguments).
        :type args: list
        :param kwargs: Arbitrary application payload for the event (keyword arguments).
        :type kwargs: dict
        :returns int -- The event publication ID assigned by the broker.
        """
        if six.PY2 and type(topic) == str:
            topic = six.u(topic)
        assert (type(topic) == six.text_type)

        # this will get filled and later serialized into HTTP/POST body
        event = {'topic': topic}

        if 'options' in kwargs:
            event['options'] = kwargs.pop('options')
            assert (type(event['options']) == dict)

        if args:
            event['args'] = args

        if kwargs:
            event['kwargs'] = kwargs

        try:
            body = json.dumps(event, separators=(',', ':'))
            if six.PY3:
                body = body.encode('utf8')

        except Exception as e:
            raise Exception(
                "invalid event payload - not JSON serializable: {0}".format(e))

        params = {
            'timestamp': _utcnow(),
            'seq': self._seq,
        }

        if self._key:
            # if the request is to be signed, create extra fields and signature
            params['key'] = self._key
            params['nonce'] = random.randint(0, 9007199254740992)

            # HMAC[SHA256]_{secret} (key | timestamp | seq | nonce | body) => signature

            hm = hmac.new(self._secret.encode('utf8'), None, hashlib.sha256)
            hm.update(params['key'].encode('utf8'))
            hm.update(params['timestamp'].encode('utf8'))
            hm.update(u"{0}".format(params['seq']).encode('utf8'))
            hm.update(u"{0}".format(params['nonce']).encode('utf8'))
            hm.update(body)
            signature = base64.urlsafe_b64encode(hm.digest())

            params['signature'] = signature

        self._seq += 1

        path = "{0}?{1}".format(parse.quote(self._endpoint['path']),
                                parse.urlencode(params))

        # now issue the HTTP/POST
        self._connection.request('POST', path, body, self._endpoint['headers'])
        response = self._connection.getresponse()
        response_body = response.read().decode()

        if response.status != 202:
            raise Exception(
                "publication request failed {0} [{1}] - {2}".format(
                    response.status, response.reason, response_body))

        try:
            res = json.loads(response_body)
        except Exception as e:
            raise Exception("publication request bogus result - {0}".format(e))

        return res['id']
Beispiel #49
0
    def numeric_phrase(cls,
                       key,
                       num,
                       language,
                       country=None,
                       dictionaries=(),
                       strict_numeric=False,
                       is_alpha=False):
        has_alpha = False
        has_numeric = True
        is_integer = False
        is_none = False
        if num is not None:
            try:
                num_int = int(num)
                is_integer = True
            except ValueError:
                try:
                    num_float = float(num)
                except ValueError:
                    tokens = tokenize(safe_decode(num))
                    has_numeric = False
                    for t, c in tokens:
                        if c == token_types.NUMERIC:
                            has_numeric = True
                        if any((ch.isalpha() for ch in t)):
                            has_alpha = True

                    if strict_numeric and has_alpha:
                        return safe_decode(num)

        else:
            is_none = True

        values, probs = None, None

        if is_alpha:
            values, probs = address_config.alternative_probabilities(
                '{}.alpha'.format(key),
                language,
                dictionaries=dictionaries,
                country=country)

        # Pick a phrase given the probability distribution from the config
        if values is None:
            values, probs = address_config.alternative_probabilities(
                key, language, dictionaries=dictionaries, country=country)

        if not values:
            return safe_decode(num) if not is_none else None

        phrase, phrase_props = weighted_choice(values, probs)

        values = []
        probs = []

        # Dictionaries are lowercased, so title case here
        if phrase_props.get('title_case', True):
            phrase = phrase.title()
        '''
        There are a few ways we can express the number itself

        1. Alias it as some standalone word like basement (for floor "-1")
        2. Use the number itself, so "Floor 2"
        3. Append/prepend an affix e.g. 2/F for second floor
        4. As an ordinal expression e.g. "2nd Floor"
        '''
        have_standalone = False
        have_null = False
        for num_type in ('standalone', 'null', 'numeric', 'numeric_affix',
                         'ordinal'):
            key = '{}_probability'.format(num_type)
            prob = phrase_props.get(key)
            if prob is not None:
                if num_type == 'standalone':
                    have_standalone = True
                elif num_type == 'null':
                    have_null = True
                values.append(num_type)
                probs.append(prob)
            elif num_type in phrase_props:
                values.append(num_type)
                probs.append(1.0)
                break

        if not probs or is_none:
            return phrase

        # If we're using something like "Floor A" or "Unit 2L", remove ordinal/affix items
        if has_alpha:
            values, probs = zip(*[(v, p) for v, p in zip(values, probs)
                                  if v in ('numeric', 'null', 'standalone')])
            total = float(sum(probs))
            if isclose(total, 0.0):
                return None

            probs = [p / total for p in probs]

        probs = cdf(probs)

        if len(values) < 2:
            if have_standalone:
                num_type = 'standalone'
            elif have_null:
                num_type = 'null'
            else:
                num_type = 'numeric'
        else:
            num_type = weighted_choice(values, probs)

        if num_type == 'standalone':
            return phrase
        elif num_type == 'null':
            return safe_decode(num)

        props = phrase_props[num_type]

        if is_integer:
            num_int = int(num)
            if phrase_props.get('number_abs_value', False):
                num_int = abs(num_int)
                num = num_int

            if 'number_min_abs_value' in phrase_props and num_int < phrase_props[
                    'number_min_abs_value']:
                return None

            if 'number_max_abs_value' in phrase_props and num_int > phrase_props[
                    'number_max_abs_value']:
                return None

            if phrase_props.get('number_subtract_abs_value'):
                num_int -= phrase_props['number_subtract_abs_value']
                num = num_int

        num = safe_decode(num)
        digits_props = props.get('digits')
        if digits_props:
            # Inherit the gender and category e.g. for ordinals
            for k in ('gender', 'category'):
                if k in props:
                    digits_props[k] = props[k]
            num = Digits.rewrite(num,
                                 language,
                                 digits_props,
                                 num_type=Digits.CARDINAL
                                 if num_type != 'ordinal' else Digits.ORDINAL)

        # Do we add the numeric phrase e.g. Floor No 1
        add_number_phrase = props.get('add_number_phrase', False)
        if add_number_phrase and random.random(
        ) < props['add_number_phrase_probability']:
            num = Number.phrase(num, language, country=country)

        whitespace_default = True

        if num_type == 'numeric_affix':
            phrase = props['affix']
            if props.get('upper_case', True):
                phrase = phrase.upper()
            if 'zero_pad' in props and num.isdigit():
                num = num.rjust(props['zero_pad'], props.get('zero_char', '0'))
            whitespace_default = False
        elif num_type == 'ordinal' and safe_decode(num).isdigit():
            ordinal_expression = ordinal_expressions.suffixed_number(
                num, language, gender=props.get('gender', None))

            if ordinal_expression is not None:
                num = ordinal_expression

        if 'null_phrase_probability' in props and (
                num_type == 'ordinal' or
            (has_alpha and
             (has_numeric or 'null_phrase_alpha_only' in props))):
            if random.random() < props['null_phrase_probability']:
                return num

        direction = props['direction']
        whitespace = props.get('whitespace', whitespace_default)

        whitespace_probability = props.get('whitespace_probability')
        if whitespace_probability is not None:
            whitespace = random.random() < whitespace_probability

        # Occasionally switch up if direction_probability is specified
        if random.random() > props.get('direction_probability', 1.0):
            if direction == 'left':
                direction = 'right'
            elif direction == 'right':
                direction = 'left'

        whitespace_phrase = six.u(' ') if whitespace else six.u('')
        # Phrase goes to the left of hte number
        if direction == 'left':
            return six.u('{}{}{}').format(phrase, whitespace_phrase, num)
        # Phrase goes to the right of the number
        elif direction == 'right':
            return six.u('{}{}{}').format(num, whitespace_phrase, phrase)
        # Need to specify a direction, otherwise return naked number
        else:
            return safe_decode(num)
Beispiel #50
0
def _filter_model(pkg, args):
    to_search = [six.u(pkg["name"]), six.u(pkg["summary"])]
    return util.match_filters(args.terms, to_search)
Beispiel #51
0
def notify(args):
    notifier = Notifier(from_addr=ICINGA_EMAIL)
    env = (dict(
        TARGET_TYPE='service',
        NAGIOS_LONGDATETIME='2016-05-11 16:30:50 +8000',
        NAGIOS_NOTIFICATIONTYPE='PROBLEM',
        NAGIOS_HOSTALIAS='sa',
        NAGIOS_SERVICEDESC='fakeservice',
        NAGIOS_SERVICEOUTPUT="整个中文试试",
        NAGIOS_SERVICESTATE='CRITICAL',
        NOTIFICATIONAUTHORNAME='sysadmin',
        NOTIFICATIONCOMMENT='没病走两步~',
        NOTIFICATION_IS_ARCHIVE=False,
        NAGIOS_CONTACTNAME='shuaisa',
        SERVICE_DURATION_SEC='5.001102',
    ) if args.test else os.environ)

    unicode_env = {}
    for name, value in env.items():
        if isinstance(value, six.string_types):
            unicode_env[six.ensure_text(name)] = six.ensure_text(value)
        else:
            unicode_env[six.ensure_text(name)] = value

    env = AttrDict(unicode_env, _default_value=six.u(''))

    short_env = dict(type=env.NAGIOS_NOTIFICATIONTYPE[:3].upper(),
                     host=env.NAGIOS_HOSTALIAS,
                     hoststate=env.HOSTSTATE,
                     service=env.NAGIOS_SERVICEDESC,
                     time=' '.join(env.NAGIOS_LONGDATETIME.split()[:2]),
                     extra=(env.NAGIOS_HOSTOUTPUT if env.TARGET_TYPE == 'host'
                            else env.NAGIOS_SERVICEOUTPUT),
                     link='',
                     wiki_base_url=ALERT_WIKI_BASE_URL.rstrip(' /'))
    duration = env.SERVICE_DURATION_SEC if env.TARGET_TYPE == 'service' \
        else env.HOST_DURATION_SEC

    short_env = AttrDict(short_env, _default_value='')
    ack_link = icinga_cluster_config.get_ack_link(env)
    reboot_host_link = icinga_cluster_config.get_reboot_host_link(env)
    icinga_link = icinga_cluster_config.get_icinga_link(env)
    for type_ in NOTIFY_TYPES:
        values = vars(args)[type_]
        if values:
            addrs = [i for v in values for i in re.split(r'[,\s]+', v)]
            addrs = [a for a in addrs if a]
            if not addrs:
                logger.warning('ignore empty %s addrs' % type_)
                continue
            title, content = render_notification(
                env=env,
                short_env=short_env,
                notify_type=type_,
                ack_link=ack_link,
                reboot_host_link=reboot_host_link,
                icinga_link=icinga_link)
            try:
                ok = add_notification(env.NAGIOS_NOTIFICATIONTYPE,
                                      short_env.host, short_env.hoststate,
                                      short_env.service, content, type_,
                                      ', '.join(addrs), duration)
                logger.info('notification gateway permit: %s', ok)
            except Exception:
                # we catch the exception and send it to sentry, but let the program continue to run
                report()
                logger.exception('add notification to gateway failed: ')
                ok = True
            if ok:
                try:
                    getattr(notifier, type_)(addrs,
                                             title=title,
                                             content=content)
                except Exception as e:
                    report()
                    logger.error('Notifier.%s(%s) failed: %s', type_, addrs, e)
Beispiel #52
0
 def rewrite_full_width(cls, s):
     return six.u('').join(
         [cls.unicode_full_width_map.get(c, c) for c in s])
Beispiel #53
0
def ra(value):
    return value\
        .replace(u("ą"), "a").replace(u("Ą"), "a")\
        .replace(u("ć"), "c").replace(u("Ć"), "c")\
        .replace(u("ę"), "e").replace(u("Ę"), "e")\
        .replace(u("ł"), "l").replace(u("Ł"), "l")\
        .replace(u("ń"), "n").replace(u("Ń"), "n")\
        .replace(u("ó"), "o").replace(u("Ó"), "o")\
        .replace(u("ś"), "s").replace(u("Ś"), "s")\
        .replace(u("ź"), "z").replace(u("Ź"), "z")\
        .replace(u("ż"), "z").replace(u("Ż"), "z")\
        .lower()
Beispiel #54
0
def test_inventory_name_with_unicode(inventory, inventory_source):
    inventory.name = six.u('オオオ')
    inventory.save()
    iu = inventory_source.update()
    assert iu.name.startswith(inventory.name)
Beispiel #55
0
    def read_datetime(self, value, out_fmt, in_fmt=None):

        if type(value) != datetime.datetime and in_fmt is not None:
            value = datetime.datetime.strptime(value, in_fmt)
        elif type(value) == datetime.datetime:
            pass
        else:
            raise TypeError('Either datetime must be supplied or both '
                            'value and in_fmt')

        MONTHS = [
            u(""),
            u("stycznia"),
            u("lutego"),
            u("marca"),
            u("kwietnia"),
            u("maja"),
            u("czerwca"),
            u("lipca"),
            u("sierpnia"),
            u("września"),
            u("października"),
            u("listopada"),
            u("grudnia"),
        ]

        DAYS_N0 = [
            u(""),
            u(""),
            u("dwudziestego"),
            u("trzydziestego"),
        ]
        DAYS_N = [
            u(""),
            u("pierwszego"),
            u("drugiego"),
            u("trzeciego"),
            u("czwartego"),
            u("piątego"),
            u("szóstego"),
            u("siódmego"),
            u("ósmego"),
            u("dziewiątego"),
            u("dziesiątego"),
            u("jedenastego"),
            u("dwunastego"),
            u("trzynastego"),
            u("czternastego"),
            u("piętnastego"),
            u("szesnastego"),
            u("siedemnastego"),
            u("osiemnastego"),
            u("dziewiętnastego"),
        ]
        HOURS = [
            u("zero"),
            u("pierwsza"),
            u("druga"),
            u("trzecia"),
            u("czwarta"),
            u("piąta"),
            u("szósta"),
            u("siódma"),
            u("ósma"),
            u("dziewiąta"),
            u("dziesiąta"),
            u("jedenasta"),
            u("dwunasta"),
            u("trzynasta"),
            u("czternasta"),
            u("piętnasta"),
            u("szesnasta"),
            u("siedemnasta"),
            u("osiemnasta"),
            u("dziewiętnasta"),
            u("dwudziesta"),
        ]

        _, tm_mon, tm_mday, tm_hour, tm_min, _, _, _, _ = value.timetuple()
        retval = []
        for word in out_fmt.split(" "):
            if word == '%d':  # Day of the month
                if tm_mday <= 20:
                    retval.append(DAYS_N[tm_mday])
                else:
                    retval.append(DAYS_N0[tm_mday // 10])
                    retval.append(DAYS_N[tm_mday % 10])
            elif word == '%B':  # Month as locale’s full name
                retval.append(MONTHS[tm_mon])
            elif word == '%H':  # Hour (24-hour clock) as a decimal number
                if tm_hour <= 20:
                    retval.append(HOURS[tm_hour])
                elif tm_hour > 20:
                    retval.append(HOURS[20])
                    retval.append(HOURS[tm_hour - 20])
            elif word == '%M':  # Minute as a decimal number
                if tm_min == 0:
                    retval.append(u('zero-zero'))
                else:
                    retval.append(read_number(tm_min))
            elif word.startswith('%'):
                raise ValueError("Token %s' is not supported!", word)
            else:
                retval.append(word)
        return ' '.join((w for w in retval if w != ''))
Beispiel #56
0
import threading
import pyperf
import six
from six.moves import xrange
import tracemalloc
import gc
import os
import psutil
import time

EMPTY = ({}, 2000)
SIMPLE_DATA = {'key1': 0, 'key2': True, 'key3': 'value', 'key4': 'foo',
               'key5': 'string'}
SIMPLE = (SIMPLE_DATA, 1000)
NESTED_DATA = {'key1': 0, 'key2': SIMPLE[0], 'key3': 'value', 'key4': SIMPLE[0],
               'key5': SIMPLE[0], six.u('key'): six.u('\u0105\u0107\u017c')}
NESTED = (NESTED_DATA, 1000)
HUGE = ([NESTED[0]] * 1000, 1)

CASES = ['EMPTY', 'SIMPLE', 'NESTED', 'HUGE']

def bench_json_dumps(data):
    for obj, count_it in data:
        for _ in count_it:
            json.dumps(obj)

def add_cmdline_args(cmd, args):
    if args.cases:
        cmd.extend(("--cases", args.cases))

def functionWorker(tid, tname, allocate_pkey):
Beispiel #57
0
                    retval.append(read_number(int(char)))
                except ValueError:
                    raise ValueError("\"%s\" is not a element of callsign",
                                     char)
        return ' '.join(retval)


# ##########################################
#
# module dependant words
# #############################################

# World Weather Online

wwo_weather_codes = {
    '113': _(ra(u('bezchmurnie'))),  # Clear/Sunny
    '116': _(ra(u('częściowe zachmurzenie'))),  # Partly Cloudy
    '119': _(ra(u('pochmurno'))),  # Cloudy
    '122': _(ra(u('zachmurzenie całkowite'))),  # Overcast
    '143': _(ra(u('zamglenia'))),  # Mist
    '176': _(ra(u('lokalne przelotne opady deszczu'))),  # Patchy rain nearby
    '179': _(ra(u('śnieg'))),  # Patchy snow nearby
    '182': _(ra(u('śnieg z deszczem'))),  # Patchy sleet nearby
    '185': _(ra(u('lokalna przelotna marznąca mżawka'))
             ),  # Patchy freezing drizzle nearby
    '200': _(ra(u('lokalne burze'))),  # Thundery outbreaks in nearby
    '227': _(ra(u('zamieć śnieżna'))),  # Blowing snow
    '230': _(ra(u('zamieć śnieżna'))),  # Blizzard
    '248': _(ra(u('mgła'))),  # Fog
    '260': _(ra(u('marznąca mgła'))),  # Freezing fog
    '263': _(ra(u('mżawka'))),  # Patchy light drizzle
Beispiel #58
0
 def read_callsign(self, value):
     # literowanie polskie wg. "Krótkofalarstwo i radiokomunikacja - poradnik",
     # Łukasz Komsta SQ8QED, Wydawnictwa Komunikacji i Łączności Warszawa, 2001,
     # str. 130
     LETTERS = {
         'a': u('adam'),
         'b': u('barbara'),
         'c': u('celina'),
         'd': u('dorota'),
         'e': u('edward'),
         'f': u('franciszek'),
         'g': u('gustaw'),
         'h': u('henryk'),
         'i': u('irena'),
         'j': u('józef'),
         'k': u('karol'),
         'l': u('ludwik'),
         'm': u('marek'),
         'n': u('natalia'),
         'o': u('olga'),
         'p': u('paweł'),
         'q': u('quebec'),
         'r': u('roman'),
         's': u('stefan'),
         't': u('tadeusz'),
         'u': u('urszula'),
         'v': u('violetta'),
         'w': u('wacław'),
         'x': u('xawery'),
         'y': u('ypsilon'),
         'z': u('zygmunt'),
         '/': u('łamane'),
     }
     retval = []
     for char in value.lower():
         try:
             retval.append(LETTERS[char])
         except KeyError:
             try:
                 retval.append(read_number(int(char)))
             except ValueError:
                 raise ValueError("\"%s\" is not a element of callsign",
                                  char)
     return ' '.join(retval)
Beispiel #59
0
 def test_strings(self):
     self.assertEqual(always_iterable('foo'), ('foo',))
     self.assertEqual(always_iterable(six.b('bar')), (six.b('bar'),))
     self.assertEqual(always_iterable(six.u(b'baz')), (six.u(b'baz'),))
Beispiel #60
0
 def read_degrees(self, value):
     deg = [u("stopień"), u("stopnie"), u("stopni")]
     return read_number(value, deg)