Пример #1
0
 def test_parser(self):
     self.check_parse(1, "1")
     self.check_parse(Symbol("a*b"), 'a*b')
     self.check_parse("ab", '"ab"')
     self.check_parse('a"b', r'"a\"b"')
     self.check_parse("blah\n", '"blah\n"')
     self.check_parse([1, 2, 3], "[1 2 3]")
     self.check_parse({1, 2, 3}, "#{1 2 3}")
     self.check_parse([1, True, None], "[1 true nil]")
     self.check_parse("c", r"\c")
     self.check_parse("\n", r"\newline")
     self.check_parse(Keyword("abc"), ":abc")
     self.check_parse([Keyword("abc"), 1, True, None], "[:abc 1 true nil]")
     self.check_parse((Keyword("abc"), 1, True, None), "(:abc 1 true nil)")
     self.check_parse(tuple(), "()")
     self.check_parse(set(), "#{}")
     self.check_parse({}, "{}")
     self.check_parse([], "[]")
     self.check_parse({"a": [1, 2, 3]}, '{"a" [1 2 3]}')
     self.check_parse(
         datetime.datetime(2012, 12, 22, 19, 40, 18, 0, tzinfo=pytz.utc),
         '#inst "2012-12-22T19:40:18Z"')
     self.check_parse(datetime.date(2011, 10, 9), '#inst "2011-10-09"')
     self.check_parse("|", "\"|\"")
     self.check_parse("%", "\"%\"")
     self.check_parse(['bl"ah'], r"""["bl\"ah"]""")
     self.check_parse("blah\n", '"blah\n"')
     self.check_parse('"', r'"\""')
     self.check_parse('\\', r'"\\"')
     self.check_parse(["abc", "123"], '["abc", "123"]')
     self.check_parse({"key": "value"}, '{"key" "value"}')
     self.check_parse(
         frozenset({ImmutableList([u"ab", u"cd"]),
                    ImmutableList([u"ef"])}), '#{["ab", "cd"], ["ef"]}')
Пример #2
0
 def test_equality(self):
     self.assertTrue("db/id" != Keyword("db/id"))
     self.assertTrue("db/id" != Symbol("db/id"))
     self.assertTrue(Symbol("db/id") != Keyword("db/id"))
     self.assertTrue("db/id" == "db/id")
     self.assertTrue(Keyword("db/id") == Keyword("db/id"))
     self.assertTrue(Symbol("db/id") == Symbol("db/id"))
Пример #3
0
 def test_round_trip_sets(self):
     step1 = '#{:a (1 2 3) :b}'
     step2 = loads(step1)
     step3 = dumps(step2)
     step4 = loads(step3)
     self.assertIn(Keyword("a"), step4)
     self.assertIn(Keyword("b"), step4)
     self.assertIn((1, 2, 3), step4)
 def get_best_pattern(self, user_id, tick):
     response = self.send_stuff(
         self._PORT_REQ, {"request-type": Keyword("get-best-pattern"),
                          "user-id": user_id})
     pattern_string = isinstance(response[Keyword("pattern")], str)
     type_correct = (response[Keyword("response-type")] == Keyword("vibrate"))
     if (not pattern_string) or (not type_correct):
         raise Exception
     return self.check_data(response[Keyword("security-token")], tick)
Пример #5
0
 def test_dump(self):
     self.check_dump("#{1 2 3}", {1, 2, 3})
     self.check_dump([
         '{:bar [1 2 3] "foo" :gone :a 1}',
         '{:a 1 "foo" :gone :bar [1 2 3]}'
     ], {
         Keyword("a"): 1,
         "foo": Keyword("gone"),
         Keyword("bar"): [1, 2, 3]
     })
Пример #6
0
 def test_with_namespace(self):
     for (expected, keyword, namespace) in (
         ("k", "k", None),
         ("k", "n/k", None),
         ("n/k", "k", "n"),
         ("n/k", "x/k", "n"),
         ("n/a/b/c", "x/a/b/c", "n"),
     ):
         self.assertEqual(Keyword(expected),
                          Keyword(keyword).with_namespace(namespace))
Пример #7
0
 def fromconfig(cls, repository: "Repository", config: Dict,
                stations_map: Dict[str, Station],
                handlers_map: Dict[str, Handler]):
     channel_name = config[Keyword("name")]
     channel_id = config[Keyword("id")]
     channel_timetable = Timetable.fromconfig(config[Keyword("timetable")],
                                              stations_map)
     channel_handlers = tuple(handlers_map[name]
                              for name in config[Keyword("handlers")])
     return cls(channel_id, channel_name, repository, channel_timetable,
                channel_handlers)
Пример #8
0
 def test_dump(self):
     self.check_roundtrip({1, 2, 3})
     self.check_roundtrip({
         Keyword("a"): 1,
         "foo": Keyword("gone"),
         Keyword("bar"): [1, 2, 3]
     })
     self.check_roundtrip(uuid4())
     self.check_roundtrip(datetime.date(1354, 6, 7))
     self.check_roundtrip(
         datetime.datetime(1900, 6, 7, 23, 59, 59, tzinfo=pytz.utc))
    def send_data(self, user_id, tick):
        result = []
        patterns = self.retrieve_yaml(user_id)
        for pattern in patterns:
            request = {"request-type": Keyword("send-data"),
                       "user-id": user_id, "pattern": pattern,
                       "excitement-level": random.random()}
            response = self.send_stuff(self._PORT_REQ, request)
            result.append(self.check_data(response[Keyword("security-token")], tick))

        return result
Пример #10
0
    def get_patterns(self, user_id, tick):
        request = {"request-type": Keyword("get-patterns"),
                   "user-id": user_id}
        response = self.send_stuff(self._PORT_REQ, request)
        patterns = response[Keyword("patterns")]

        self.logger.info("patterns for %s are %s", str(user_id), str(patterns))

        # store patterns
        self.store_yaml(user_id, patterns)

        return self.check_data(response[Keyword("security-token")], tick)
Пример #11
0
 def test_parser(self):
     self.check_parse(1, "1")
     self.check_parse([1, 2, 3], "[1 2 3]")
     self.check_parse({1, 2, 3}, "#{1 2 3}")
     self.check_parse([1, True, None], "[1 true nil]")
     self.check_parse("c", r"\c")
     self.check_parse("\n", r"\newline")
     self.check_parse(Keyword("abc"), ":abc")
     self.check_parse([Keyword("abc"), 1, True, None], "[:abc 1 true nil]")
     self.check_parse((Keyword("abc"), 1, True, None), "(:abc 1 true nil)")
     self.check_parse({"a": [1, 2, 3]}, '{"a" [1 2 3]}')
     self.check_parse(
         datetime.datetime(2012, 12, 22, 19, 40, 18, 0, tzinfo=pytz.utc),
         '#inst "2012-12-22T19:40:18Z"')
Пример #12
0
 def test_parser_single_expressions(self):
     for expected, edn_string in (
         (1, "1"),
         (16768115, "0xFFDC73"),
         (Symbol("xFF"), "xFF"),
         (Symbol("a*b"), 'a*b'),
         ("ab", '"ab"'),
         ('a"b', r'"a\"b"'),
         ("blah\n", '"blah\n"'),
         ([1, 2, 3], "[1 2 3]"),
         ({1, 2, 3}, "#{1 2 3}"),
         ([1, True, None], "[1 true nil]"),
         ("c", r"\c"),
         ("\n", r"\newline"),
         (u"Σ", u"\\Σ"),
         (u"λ", r"\u03bB"),
         (Keyword("abc"), ":abc"),
         ([Keyword("abc"), 1, True, None], "[:abc 1 true nil]"),
         ((Keyword("abc"), 1, True, None), "(:abc 1 true nil)"),
         (tuple(), "()"),
         (set(), "#{}"),
         ({}, "{}"),
         ([], "[]"),
         ({
             "a": [1, 2, 3]
         }, '{"a" [1 2 3]}'),
         (datetime.datetime(2012, 12, 22, 19, 40, 18, 0, tzinfo=pytz.utc),
          '#inst "2012-12-22T19:40:18Z"'),
         (datetime.date(2011, 10, 9), '#inst "2011-10-09"'),
         ("|", "\"|\""),
         ("%", "\"%\""),
         (['bl"ah'], r"""["bl\"ah"]"""),
         ("blah\n", '"blah\n"'),
         ('"', r'"\""'),
         ('\\', r'"\\"'),
         (["abc", "123"], '["abc", "123"]'),
         ({
             "key": "value"
         }, '{"key" "value"}'),
         (frozenset({ImmutableList([u"ab", u"cd"]),
                     ImmutableList([u"ef"])}), '#{["ab", "cd"], ["ef"]}'),
         (fractions.Fraction(2, 3), "2/3"),
         ((2, Symbol('/'), 3), "(2 / 3)"),
     ):
         self.check_parse(expected, edn_string)
         self.check_parse_all([expected], edn_string)
Пример #13
0
 def search(current_dict: dict):
     for key in current_dict.keys():
         data = current_dict[key]
         if not isinstance(data, ImmutableDict):
             continue
         param_type = data.get(Keyword('type'))
         param_example = data.get(Keyword('example'))
         param_description = data.get(Keyword('description'))
         if param_type and param_example:
             param_key = key.name.replace('?', '')
             if param_type == 'array':
                 param_value = ast.literal_eval(param_example)
             else:
                 param_value = str(param_example)
             edn_dump[param_key] = param_value
         elif param_type and param_description:
             param_key = key.name.replace('?', '')
             edn_dump[param_key] = 'STUB'
         else:
             search(current_dict[key])
Пример #14
0
 def send_stuff(self, port, painload):
     self.logger.info("Sending %s", str(painload))
     sock = socket(AF_INET, SOCK_STREAM)
     sock.connect((self._ip, port))
     sock.sendall(edn_format.dumps(
         {Keyword(k): v for k, v in painload.items()}).encode('utf8'))
     response = sock.recv(65535)
     self.logger.info('begin response')
     self.logger.info(response.decode('utf8'))
     self.logger.info('end response')
     val = edn_format.loads(response.decode('utf8') + " ")
     sock.close()
     return val
Пример #15
0
    def test_keyword_keys(self):
        unchanged = (
            None,
            True,
            1,
            "foo",
            {},
            {True: 42},
            {25: 42},
            {3.14: "test"},
            {Keyword("foo"): "something"},
            {Symbol("foo"): "something"},
            ["foo", "bar"],
            ("foo", "bar"),
            {1: {2: 3}},
            ImmutableDict({1: 2}),
        )

        for case in unchanged:
            self.check_roundtrip(case, keyword_keys=True)

        keyworded_keys = (
            ("{:foo 42}", {"foo": 42}),
            ("{:a {:b {:c 42} :d 1}}", {"a": {"b": {"c": 42}, "d": 1}}),
            ("[{:a 42} {:b 25}]", [{"a": 42}, {"b": 25}]),
            ("({:a 42} {:b 25})", ({"a": 42}, {"b": 25})),
            ("{1 [{:a 42}]}", {1: [{"a": 42}]}),
            ("{:foo 1}", ImmutableDict({"foo": 1})),
        )

        for expected, data in keyworded_keys:
            self.assertEqual(expected, dumps(data, keyword_keys=True))

        self.assertEqual(
                {Keyword("a"): {Keyword("b"): 2}, 3: 4},
                loads(dumps({Keyword("a"): {"b": 2}, 3: 4}, keyword_keys=True)))
Пример #16
0
    def register_user(self):
        user_id = self.generate_user_id()
        flag = self.get_flag(self.tick)

        self.logger.info("registering user %s", user_id)

        # store users
        users_blob, users_blob_name = self.get_users_blob()
        self.logger.info("old users: %s", users_blob)
        users_blob.append(user_id)
        self.store_yaml(users_blob_name, users_blob)

        self.logger.info("new users %s", users_blob)

        return {"request-type": Keyword("register-user"),
                "user-id": user_id, "security-token": flag}
Пример #17
0
def updateVmServiceImage(windowsVersions):
    vmServiceRepo = "github.com/circleci/vm-service.git"
    vmConfigFile = "config/config.edn"
    vmChartFile = "chrats/vm-service/templates/vm-service-config.yaml"

    vmServiceGit = Gitter("vm_service", vmServiceRepo, "windows-update/" + str(uuid4()))
    vmServiceGit.clone()
    vmServiceGit.branch()

    vmConfigPath = os.path.join(vmServiceGit.repoDir, vmConfigFile)
    vmChartPath = os.path.join(vmServiceGit.repoDir, vmChartFile)

    chartData = YAML()
    chartConfig = None

    config = None

    with open(vmChartPath, 'r') as chartFile:
        imageStubs = ["windows-server-2019-vs2019:", "windows-server-2019-nvidia-small:",
                "windows-server-2019-nvidia-medium:", "windows-server-2019-nvidia-large:"]
        imageTags = ["stable", "edge", "canary"]

        chartConfig = loads(chartData.load(chartFile)["data"]) # image config is in EDN format
        vmImages = chartConfig[Keyword("vm-manager")][Keyword("images")]
        for i in imageStubs:
            for tag in imageTags:
                vmImages[i+tag] = windowsVersions[i]

        chartConfig[Keyword("vm-manager")][Keyword("images")] = vmImages
        

    with open(vmConfigPath, 'r') as configFile:
        config = loads(configFile.read())
        configImages = config[Keyword("vm-manager")][Keyword("images")]["gce"]
        configImages["windows-server-2019:e2e-test"] = windowsVersions["windows-server-2019-base"]
        configImages["windows-server-2019-vs2019:e2e-test"] = windowsVersions["windows-server-2019-nvidia-small"]
Пример #18
0
 def test_list(self):
     self.check_parse("()", tuple())
     self.check_parse("(:abc 1 true nil)", (Keyword("abc"), 1, True, None))
Пример #19
0
 def test_hashing(self):
     pop_count = len(
         set(map(hash, ["db/id", Keyword("db/id"),
                        Symbol("db/id")])))
     self.assertEqual(pop_count, 3)
Пример #20
0
    def test_indent(self):
        fixture = {"foo": "bar"}
        self.check_dumps('{"foo" "bar"}', fixture, indent=None)

        fixture = {Keyword("a"): {Keyword("b"): "foo"}}
        self.check_dumps('''\
{
:a {
:b "foo"
}
}''', fixture, indent=0)

        fixture = (1, Keyword("b"), "foo")
        self.check_dumps('''\
(
 1
 :b
 "foo"
)''', fixture, indent=1)

        fixture = [1, Keyword("b"), "foo", {Keyword("foo"): Keyword("bar")}]
        self.check_dumps('''\
[
  1
  :b
  "foo"
  {
    :foo :bar
  }
]''',
                         fixture,
                         indent=2)

        fixture = {1, 2, 3}
        self.check_dumps('''\
#{
    1
    2
    3
}''',
                         fixture,
                         indent=4,
                         sort_sets=True)

        fixture = [{"a": 42}]
        self.check_dumps('''\
[
  {
    :a 42
  }
]''',
                         fixture,
                         keyword_keys=True,
                         indent=2)

        fixture = [[1, 2, 3]]
        self.check_dumps('''\
[
  [
    1
    2
    3
  ]
]''',
                         fixture,
                         indent=2)

        fixture = {
            "a":
            "foo",
            "b": {
                "c": [Keyword("a"), Keyword("b"),
                      Keyword("c")]
            },
            "d": {1, 2, 3},
            "e": (datetime.date(2011, 10, 9),
                  UUID("urn:uuid:1e4856a2-085e-45df-93e1-41a0c7aeab2e"),
                  datetime.datetime(2012,
                                    12,
                                    22,
                                    19,
                                    40,
                                    18,
                                    0,
                                    tzinfo=pytz.utc))
        }
        self.check_dumps('''\
{
  :a "foo"
  :b {
    :c [
      :a
      :b
      :c
    ]
  }
  :d #{
    1
    2
    3
  }
  :e (
    #inst "2011-10-09"
    #uuid "1e4856a2-085e-45df-93e1-41a0c7aeab2e"
    #inst "2012-12-22T19:40:18.000000Z"
  )
}''',
                         fixture,
                         keyword_keys=True,
                         sort_keys=True,
                         sort_sets=True,
                         indent=2)
Пример #21
0
 def test_namespace(self):
     self.assertIsNone(Keyword("foo").namespace)
     self.assertEqual("a", Keyword("a/b").namespace)
     self.assertEqual("a", Keyword("a/b/d").namespace)
Пример #22
0
 def test_name(self):
     for name in ("foo", "a/b", "a/b/c", "a:::::::b"):
         self.assertEqual(name, Keyword(name).name)
Пример #23
0
 def get_status(self):
     return {"request-type": Keyword("status")}
Пример #24
0
import edn_format
from edn_format import Keyword
from sunflower.core.channel import Channel
from sunflower.core.repository import RedisRepository
from sunflower.stations import FranceCulture
from sunflower.stations import FranceInfo
from sunflower.stations import FranceInter
from sunflower.stations import FranceInterParis
from sunflower.stations import FranceMusique
from sunflower.stations import PycolorePlaylistStation
from sunflower.stations import RTL2

# read definitions
with open("sunflower/conf.edn") as f:
    definitions = edn_format.loads(f.read())
channels_definitions = definitions[Keyword("channels")]
stations_definitions = definitions[Keyword("stations")]

# instantiate repository
redis_repository = RedisRepository()

# instantiate URL stations
stations = {
    station_cls.name: station_cls()
    for station_cls in [
        FranceCulture, FranceInfo, FranceInter, FranceMusique,
        FranceInterParis, RTL2
    ]
}

# add dynamic stations
Пример #25
0
 def check_success(self, response):
     try:
         return response[Keyword("response-type")] == Keyword("success")
     except:
         return False
Пример #26
0
 def test_keyword(self):
     self.check_parse(":abc", Keyword("abc"))
Пример #27
0
import edn_format
from edn_format import Keyword
from fastapi import HTTPException
from server.proxies import ChannelProxy
from server.proxies import Proxy
from sunflower.core.repository import RedisRepository
from sunflower.core.stations import REVERSE_STATIONS
# noinspection PyUnresolvedReferences
from sunflower.stations import *  # needed for view objects generation

redis_repo = RedisRepository()

# read definitions
with open("sunflower/conf.edn") as f:
    definitions = edn_format.loads(f.read())
channels_definitions = definitions[Keyword("channels")]
stations_definitions = definitions[Keyword("stations")]
channels_ids = [channel_def[Keyword("id")] for channel_def in channels_definitions]


def get_channel_or_404(channel: str):
    if channel not in channels_ids:
        raise HTTPException(404, f"Channel {channel} does not exist")
    return ChannelProxy(redis_repo, channel)


def get_station_or_404(view_function):
    """Decorator checking if station is a valid endpoint to a dynamic station."""
    @functools.wraps(view_function)
    def wrapper(station: str, *args, **kwargs):
        station_cls = REVERSE_STATIONS.get(station)
Пример #28
0
 def test_combined(self):
     self.check_roundtrip({Keyword("a"): 1,
                           "foo": Keyword("gone"),
                           Keyword("bar"): [1, 2, 3]},
                          from_python=True)
Пример #29
0
 def test_vector(self):
     self.check_parse("[]", [])
     self.check_parse("[1 2 3]", [1, 2, 3])
     self.check_parse("[1 true nil]", [1, True, None])
     self.check_parse('["abc", "123"]', ["abc", "123"])
     self.check_parse("[:abc 1 true nil]", [Keyword("abc"), 1, True, None])
Пример #30
0
 def check_status(self, response):
     return response[Keyword("response-type")] == Keyword("status")