repo
stringlengths 7
55
| path
stringlengths 4
223
| func_name
stringlengths 1
134
| original_string
stringlengths 75
104k
| language
stringclasses 1
value | code
stringlengths 75
104k
| code_tokens
listlengths 19
28.4k
| docstring
stringlengths 1
46.9k
| docstring_tokens
listlengths 1
1.97k
| sha
stringlengths 40
40
| url
stringlengths 87
315
| partition
stringclasses 1
value |
|---|---|---|---|---|---|---|---|---|---|---|---|
honzajavorek/redis-collections
|
redis_collections/sortedsets.py
|
SortedSetCounter.get_score
|
def get_score(self, member, default=None, pipe=None):
"""
Return the score of *member*, or *default* if it is not in the
collection.
"""
pipe = self.redis if pipe is None else pipe
score = pipe.zscore(self.key, self._pickle(member))
if (score is None) and (default is not None):
score = float(default)
return score
|
python
|
def get_score(self, member, default=None, pipe=None):
"""
Return the score of *member*, or *default* if it is not in the
collection.
"""
pipe = self.redis if pipe is None else pipe
score = pipe.zscore(self.key, self._pickle(member))
if (score is None) and (default is not None):
score = float(default)
return score
|
[
"def",
"get_score",
"(",
"self",
",",
"member",
",",
"default",
"=",
"None",
",",
"pipe",
"=",
"None",
")",
":",
"pipe",
"=",
"self",
".",
"redis",
"if",
"pipe",
"is",
"None",
"else",
"pipe",
"score",
"=",
"pipe",
".",
"zscore",
"(",
"self",
".",
"key",
",",
"self",
".",
"_pickle",
"(",
"member",
")",
")",
"if",
"(",
"score",
"is",
"None",
")",
"and",
"(",
"default",
"is",
"not",
"None",
")",
":",
"score",
"=",
"float",
"(",
"default",
")",
"return",
"score"
] |
Return the score of *member*, or *default* if it is not in the
collection.
|
[
"Return",
"the",
"score",
"of",
"*",
"member",
"*",
"or",
"*",
"default",
"*",
"if",
"it",
"is",
"not",
"in",
"the",
"collection",
"."
] |
07ca8efe88fb128f7dc7319dfa6a26cd39b3776b
|
https://github.com/honzajavorek/redis-collections/blob/07ca8efe88fb128f7dc7319dfa6a26cd39b3776b/redis_collections/sortedsets.py#L237-L248
|
train
|
honzajavorek/redis-collections
|
redis_collections/sortedsets.py
|
SortedSetCounter.get_or_set_score
|
def get_or_set_score(self, member, default=0):
"""
If *member* is in the collection, return its value. If not, store it
with a score of *default* and return *default*. *default* defaults to
0.
"""
default = float(default)
def get_or_set_score_trans(pipe):
pickled_member = self._pickle(member)
score = pipe.zscore(self.key, pickled_member)
if score is None:
pipe.zadd(self.key, {self._pickle(member): default})
return default
return score
return self._transaction(get_or_set_score_trans)
|
python
|
def get_or_set_score(self, member, default=0):
"""
If *member* is in the collection, return its value. If not, store it
with a score of *default* and return *default*. *default* defaults to
0.
"""
default = float(default)
def get_or_set_score_trans(pipe):
pickled_member = self._pickle(member)
score = pipe.zscore(self.key, pickled_member)
if score is None:
pipe.zadd(self.key, {self._pickle(member): default})
return default
return score
return self._transaction(get_or_set_score_trans)
|
[
"def",
"get_or_set_score",
"(",
"self",
",",
"member",
",",
"default",
"=",
"0",
")",
":",
"default",
"=",
"float",
"(",
"default",
")",
"def",
"get_or_set_score_trans",
"(",
"pipe",
")",
":",
"pickled_member",
"=",
"self",
".",
"_pickle",
"(",
"member",
")",
"score",
"=",
"pipe",
".",
"zscore",
"(",
"self",
".",
"key",
",",
"pickled_member",
")",
"if",
"score",
"is",
"None",
":",
"pipe",
".",
"zadd",
"(",
"self",
".",
"key",
",",
"{",
"self",
".",
"_pickle",
"(",
"member",
")",
":",
"default",
"}",
")",
"return",
"default",
"return",
"score",
"return",
"self",
".",
"_transaction",
"(",
"get_or_set_score_trans",
")"
] |
If *member* is in the collection, return its value. If not, store it
with a score of *default* and return *default*. *default* defaults to
0.
|
[
"If",
"*",
"member",
"*",
"is",
"in",
"the",
"collection",
"return",
"its",
"value",
".",
"If",
"not",
"store",
"it",
"with",
"a",
"score",
"of",
"*",
"default",
"*",
"and",
"return",
"*",
"default",
"*",
".",
"*",
"default",
"*",
"defaults",
"to",
"0",
"."
] |
07ca8efe88fb128f7dc7319dfa6a26cd39b3776b
|
https://github.com/honzajavorek/redis-collections/blob/07ca8efe88fb128f7dc7319dfa6a26cd39b3776b/redis_collections/sortedsets.py#L250-L268
|
train
|
honzajavorek/redis-collections
|
redis_collections/sortedsets.py
|
SortedSetCounter.get_rank
|
def get_rank(self, member, reverse=False, pipe=None):
"""
Return the rank of *member* in the collection.
By default, the member with the lowest score has rank 0.
If *reverse* is ``True``, the member with the highest score has rank 0.
"""
pipe = self.redis if pipe is None else pipe
method = getattr(pipe, 'zrevrank' if reverse else 'zrank')
rank = method(self.key, self._pickle(member))
return rank
|
python
|
def get_rank(self, member, reverse=False, pipe=None):
"""
Return the rank of *member* in the collection.
By default, the member with the lowest score has rank 0.
If *reverse* is ``True``, the member with the highest score has rank 0.
"""
pipe = self.redis if pipe is None else pipe
method = getattr(pipe, 'zrevrank' if reverse else 'zrank')
rank = method(self.key, self._pickle(member))
return rank
|
[
"def",
"get_rank",
"(",
"self",
",",
"member",
",",
"reverse",
"=",
"False",
",",
"pipe",
"=",
"None",
")",
":",
"pipe",
"=",
"self",
".",
"redis",
"if",
"pipe",
"is",
"None",
"else",
"pipe",
"method",
"=",
"getattr",
"(",
"pipe",
",",
"'zrevrank'",
"if",
"reverse",
"else",
"'zrank'",
")",
"rank",
"=",
"method",
"(",
"self",
".",
"key",
",",
"self",
".",
"_pickle",
"(",
"member",
")",
")",
"return",
"rank"
] |
Return the rank of *member* in the collection.
By default, the member with the lowest score has rank 0.
If *reverse* is ``True``, the member with the highest score has rank 0.
|
[
"Return",
"the",
"rank",
"of",
"*",
"member",
"*",
"in",
"the",
"collection",
".",
"By",
"default",
"the",
"member",
"with",
"the",
"lowest",
"score",
"has",
"rank",
"0",
".",
"If",
"*",
"reverse",
"*",
"is",
"True",
"the",
"member",
"with",
"the",
"highest",
"score",
"has",
"rank",
"0",
"."
] |
07ca8efe88fb128f7dc7319dfa6a26cd39b3776b
|
https://github.com/honzajavorek/redis-collections/blob/07ca8efe88fb128f7dc7319dfa6a26cd39b3776b/redis_collections/sortedsets.py#L270-L280
|
train
|
honzajavorek/redis-collections
|
redis_collections/sortedsets.py
|
SortedSetCounter.increment_score
|
def increment_score(self, member, amount=1):
"""
Adjust the score of *member* by *amount*. If *member* is not in the
collection it will be stored with a score of *amount*.
"""
return self.redis.zincrby(
self.key, float(amount), self._pickle(member)
)
|
python
|
def increment_score(self, member, amount=1):
"""
Adjust the score of *member* by *amount*. If *member* is not in the
collection it will be stored with a score of *amount*.
"""
return self.redis.zincrby(
self.key, float(amount), self._pickle(member)
)
|
[
"def",
"increment_score",
"(",
"self",
",",
"member",
",",
"amount",
"=",
"1",
")",
":",
"return",
"self",
".",
"redis",
".",
"zincrby",
"(",
"self",
".",
"key",
",",
"float",
"(",
"amount",
")",
",",
"self",
".",
"_pickle",
"(",
"member",
")",
")"
] |
Adjust the score of *member* by *amount*. If *member* is not in the
collection it will be stored with a score of *amount*.
|
[
"Adjust",
"the",
"score",
"of",
"*",
"member",
"*",
"by",
"*",
"amount",
"*",
".",
"If",
"*",
"member",
"*",
"is",
"not",
"in",
"the",
"collection",
"it",
"will",
"be",
"stored",
"with",
"a",
"score",
"of",
"*",
"amount",
"*",
"."
] |
07ca8efe88fb128f7dc7319dfa6a26cd39b3776b
|
https://github.com/honzajavorek/redis-collections/blob/07ca8efe88fb128f7dc7319dfa6a26cd39b3776b/redis_collections/sortedsets.py#L282-L289
|
train
|
honzajavorek/redis-collections
|
redis_collections/sortedsets.py
|
SortedSetCounter.items
|
def items(
self,
min_rank=None,
max_rank=None,
min_score=None,
max_score=None,
reverse=False,
pipe=None,
):
"""
Return a list of ``(member, score)`` tuples whose ranking is between
*min_rank* and *max_rank* AND whose score is between *min_score* and
*max_score* (both ranges inclusive). If no bounds are specified, all
items will be returned.
"""
pipe = self.redis if pipe is None else pipe
no_ranks = (min_rank is None) and (max_rank is None)
no_scores = (min_score is None) and (max_score is None)
# Default scope: everything
if no_ranks and no_scores:
ret = self.items_by_score(min_score, max_score, reverse, pipe)
# Scope narrows to given score range
elif no_ranks and (not no_scores):
ret = self.items_by_score(min_score, max_score, reverse, pipe)
# Scope narrows to given rank range
elif (not no_ranks) and no_scores:
ret = self.items_by_rank(min_rank, max_rank, reverse, pipe)
# Scope narrows twice - once by rank and once by score
else:
results = self.items_by_rank(min_rank, max_rank, reverse, pipe)
ret = []
for member, score in results:
if (min_score is not None) and (score < min_score):
continue
if (max_score is not None) and (score > max_score):
continue
ret.append((member, score))
return ret
|
python
|
def items(
self,
min_rank=None,
max_rank=None,
min_score=None,
max_score=None,
reverse=False,
pipe=None,
):
"""
Return a list of ``(member, score)`` tuples whose ranking is between
*min_rank* and *max_rank* AND whose score is between *min_score* and
*max_score* (both ranges inclusive). If no bounds are specified, all
items will be returned.
"""
pipe = self.redis if pipe is None else pipe
no_ranks = (min_rank is None) and (max_rank is None)
no_scores = (min_score is None) and (max_score is None)
# Default scope: everything
if no_ranks and no_scores:
ret = self.items_by_score(min_score, max_score, reverse, pipe)
# Scope narrows to given score range
elif no_ranks and (not no_scores):
ret = self.items_by_score(min_score, max_score, reverse, pipe)
# Scope narrows to given rank range
elif (not no_ranks) and no_scores:
ret = self.items_by_rank(min_rank, max_rank, reverse, pipe)
# Scope narrows twice - once by rank and once by score
else:
results = self.items_by_rank(min_rank, max_rank, reverse, pipe)
ret = []
for member, score in results:
if (min_score is not None) and (score < min_score):
continue
if (max_score is not None) and (score > max_score):
continue
ret.append((member, score))
return ret
|
[
"def",
"items",
"(",
"self",
",",
"min_rank",
"=",
"None",
",",
"max_rank",
"=",
"None",
",",
"min_score",
"=",
"None",
",",
"max_score",
"=",
"None",
",",
"reverse",
"=",
"False",
",",
"pipe",
"=",
"None",
",",
")",
":",
"pipe",
"=",
"self",
".",
"redis",
"if",
"pipe",
"is",
"None",
"else",
"pipe",
"no_ranks",
"=",
"(",
"min_rank",
"is",
"None",
")",
"and",
"(",
"max_rank",
"is",
"None",
")",
"no_scores",
"=",
"(",
"min_score",
"is",
"None",
")",
"and",
"(",
"max_score",
"is",
"None",
")",
"# Default scope: everything",
"if",
"no_ranks",
"and",
"no_scores",
":",
"ret",
"=",
"self",
".",
"items_by_score",
"(",
"min_score",
",",
"max_score",
",",
"reverse",
",",
"pipe",
")",
"# Scope narrows to given score range",
"elif",
"no_ranks",
"and",
"(",
"not",
"no_scores",
")",
":",
"ret",
"=",
"self",
".",
"items_by_score",
"(",
"min_score",
",",
"max_score",
",",
"reverse",
",",
"pipe",
")",
"# Scope narrows to given rank range",
"elif",
"(",
"not",
"no_ranks",
")",
"and",
"no_scores",
":",
"ret",
"=",
"self",
".",
"items_by_rank",
"(",
"min_rank",
",",
"max_rank",
",",
"reverse",
",",
"pipe",
")",
"# Scope narrows twice - once by rank and once by score",
"else",
":",
"results",
"=",
"self",
".",
"items_by_rank",
"(",
"min_rank",
",",
"max_rank",
",",
"reverse",
",",
"pipe",
")",
"ret",
"=",
"[",
"]",
"for",
"member",
",",
"score",
"in",
"results",
":",
"if",
"(",
"min_score",
"is",
"not",
"None",
")",
"and",
"(",
"score",
"<",
"min_score",
")",
":",
"continue",
"if",
"(",
"max_score",
"is",
"not",
"None",
")",
"and",
"(",
"score",
">",
"max_score",
")",
":",
"continue",
"ret",
".",
"append",
"(",
"(",
"member",
",",
"score",
")",
")",
"return",
"ret"
] |
Return a list of ``(member, score)`` tuples whose ranking is between
*min_rank* and *max_rank* AND whose score is between *min_score* and
*max_score* (both ranges inclusive). If no bounds are specified, all
items will be returned.
|
[
"Return",
"a",
"list",
"of",
"(",
"member",
"score",
")",
"tuples",
"whose",
"ranking",
"is",
"between",
"*",
"min_rank",
"*",
"and",
"*",
"max_rank",
"*",
"AND",
"whose",
"score",
"is",
"between",
"*",
"min_score",
"*",
"and",
"*",
"max_score",
"*",
"(",
"both",
"ranges",
"inclusive",
")",
".",
"If",
"no",
"bounds",
"are",
"specified",
"all",
"items",
"will",
"be",
"returned",
"."
] |
07ca8efe88fb128f7dc7319dfa6a26cd39b3776b
|
https://github.com/honzajavorek/redis-collections/blob/07ca8efe88fb128f7dc7319dfa6a26cd39b3776b/redis_collections/sortedsets.py#L329-L369
|
train
|
honzajavorek/redis-collections
|
redis_collections/sortedsets.py
|
SortedSetCounter.set_score
|
def set_score(self, member, score, pipe=None):
"""
Set the score of *member* to *score*.
"""
pipe = self.redis if pipe is None else pipe
pipe.zadd(self.key, {self._pickle(member): float(score)})
|
python
|
def set_score(self, member, score, pipe=None):
"""
Set the score of *member* to *score*.
"""
pipe = self.redis if pipe is None else pipe
pipe.zadd(self.key, {self._pickle(member): float(score)})
|
[
"def",
"set_score",
"(",
"self",
",",
"member",
",",
"score",
",",
"pipe",
"=",
"None",
")",
":",
"pipe",
"=",
"self",
".",
"redis",
"if",
"pipe",
"is",
"None",
"else",
"pipe",
"pipe",
".",
"zadd",
"(",
"self",
".",
"key",
",",
"{",
"self",
".",
"_pickle",
"(",
"member",
")",
":",
"float",
"(",
"score",
")",
"}",
")"
] |
Set the score of *member* to *score*.
|
[
"Set",
"the",
"score",
"of",
"*",
"member",
"*",
"to",
"*",
"score",
"*",
"."
] |
07ca8efe88fb128f7dc7319dfa6a26cd39b3776b
|
https://github.com/honzajavorek/redis-collections/blob/07ca8efe88fb128f7dc7319dfa6a26cd39b3776b/redis_collections/sortedsets.py#L371-L376
|
train
|
honzajavorek/redis-collections
|
redis_collections/sortedsets.py
|
GeoDB.distance_between
|
def distance_between(self, place_1, place_2, unit='km'):
"""
Return the great-circle distance between *place_1* and *place_2*,
in the *unit* specified.
The default unit is ``'km'``, but ``'m'``, ``'mi'``, and ``'ft'`` can
also be specified.
"""
pickled_place_1 = self._pickle(place_1)
pickled_place_2 = self._pickle(place_2)
try:
return self.redis.geodist(
self.key, pickled_place_1, pickled_place_2, unit=unit
)
except TypeError:
return None
|
python
|
def distance_between(self, place_1, place_2, unit='km'):
"""
Return the great-circle distance between *place_1* and *place_2*,
in the *unit* specified.
The default unit is ``'km'``, but ``'m'``, ``'mi'``, and ``'ft'`` can
also be specified.
"""
pickled_place_1 = self._pickle(place_1)
pickled_place_2 = self._pickle(place_2)
try:
return self.redis.geodist(
self.key, pickled_place_1, pickled_place_2, unit=unit
)
except TypeError:
return None
|
[
"def",
"distance_between",
"(",
"self",
",",
"place_1",
",",
"place_2",
",",
"unit",
"=",
"'km'",
")",
":",
"pickled_place_1",
"=",
"self",
".",
"_pickle",
"(",
"place_1",
")",
"pickled_place_2",
"=",
"self",
".",
"_pickle",
"(",
"place_2",
")",
"try",
":",
"return",
"self",
".",
"redis",
".",
"geodist",
"(",
"self",
".",
"key",
",",
"pickled_place_1",
",",
"pickled_place_2",
",",
"unit",
"=",
"unit",
")",
"except",
"TypeError",
":",
"return",
"None"
] |
Return the great-circle distance between *place_1* and *place_2*,
in the *unit* specified.
The default unit is ``'km'``, but ``'m'``, ``'mi'``, and ``'ft'`` can
also be specified.
|
[
"Return",
"the",
"great",
"-",
"circle",
"distance",
"between",
"*",
"place_1",
"*",
"and",
"*",
"place_2",
"*",
"in",
"the",
"*",
"unit",
"*",
"specified",
"."
] |
07ca8efe88fb128f7dc7319dfa6a26cd39b3776b
|
https://github.com/honzajavorek/redis-collections/blob/07ca8efe88fb128f7dc7319dfa6a26cd39b3776b/redis_collections/sortedsets.py#L428-L443
|
train
|
honzajavorek/redis-collections
|
redis_collections/sortedsets.py
|
GeoDB.get_hash
|
def get_hash(self, place):
"""
Return the Geohash of *place*.
If it's not present in the collection, ``None`` will be returned
instead.
"""
pickled_place = self._pickle(place)
try:
return self.redis.geohash(self.key, pickled_place)[0]
except (AttributeError, TypeError):
return None
|
python
|
def get_hash(self, place):
"""
Return the Geohash of *place*.
If it's not present in the collection, ``None`` will be returned
instead.
"""
pickled_place = self._pickle(place)
try:
return self.redis.geohash(self.key, pickled_place)[0]
except (AttributeError, TypeError):
return None
|
[
"def",
"get_hash",
"(",
"self",
",",
"place",
")",
":",
"pickled_place",
"=",
"self",
".",
"_pickle",
"(",
"place",
")",
"try",
":",
"return",
"self",
".",
"redis",
".",
"geohash",
"(",
"self",
".",
"key",
",",
"pickled_place",
")",
"[",
"0",
"]",
"except",
"(",
"AttributeError",
",",
"TypeError",
")",
":",
"return",
"None"
] |
Return the Geohash of *place*.
If it's not present in the collection, ``None`` will be returned
instead.
|
[
"Return",
"the",
"Geohash",
"of",
"*",
"place",
"*",
".",
"If",
"it",
"s",
"not",
"present",
"in",
"the",
"collection",
"None",
"will",
"be",
"returned",
"instead",
"."
] |
07ca8efe88fb128f7dc7319dfa6a26cd39b3776b
|
https://github.com/honzajavorek/redis-collections/blob/07ca8efe88fb128f7dc7319dfa6a26cd39b3776b/redis_collections/sortedsets.py#L445-L455
|
train
|
honzajavorek/redis-collections
|
redis_collections/sortedsets.py
|
GeoDB.get_location
|
def get_location(self, place):
"""
Return a dict with the coordinates *place*. The dict's keys are
``'latitude'`` and ``'longitude'``.
If it's not present in the collection, ``None`` will be returned
instead.
"""
pickled_place = self._pickle(place)
try:
longitude, latitude = self.redis.geopos(self.key, pickled_place)[0]
except (AttributeError, TypeError):
return None
return {'latitude': latitude, 'longitude': longitude}
|
python
|
def get_location(self, place):
"""
Return a dict with the coordinates *place*. The dict's keys are
``'latitude'`` and ``'longitude'``.
If it's not present in the collection, ``None`` will be returned
instead.
"""
pickled_place = self._pickle(place)
try:
longitude, latitude = self.redis.geopos(self.key, pickled_place)[0]
except (AttributeError, TypeError):
return None
return {'latitude': latitude, 'longitude': longitude}
|
[
"def",
"get_location",
"(",
"self",
",",
"place",
")",
":",
"pickled_place",
"=",
"self",
".",
"_pickle",
"(",
"place",
")",
"try",
":",
"longitude",
",",
"latitude",
"=",
"self",
".",
"redis",
".",
"geopos",
"(",
"self",
".",
"key",
",",
"pickled_place",
")",
"[",
"0",
"]",
"except",
"(",
"AttributeError",
",",
"TypeError",
")",
":",
"return",
"None",
"return",
"{",
"'latitude'",
":",
"latitude",
",",
"'longitude'",
":",
"longitude",
"}"
] |
Return a dict with the coordinates *place*. The dict's keys are
``'latitude'`` and ``'longitude'``.
If it's not present in the collection, ``None`` will be returned
instead.
|
[
"Return",
"a",
"dict",
"with",
"the",
"coordinates",
"*",
"place",
"*",
".",
"The",
"dict",
"s",
"keys",
"are",
"latitude",
"and",
"longitude",
".",
"If",
"it",
"s",
"not",
"present",
"in",
"the",
"collection",
"None",
"will",
"be",
"returned",
"instead",
"."
] |
07ca8efe88fb128f7dc7319dfa6a26cd39b3776b
|
https://github.com/honzajavorek/redis-collections/blob/07ca8efe88fb128f7dc7319dfa6a26cd39b3776b/redis_collections/sortedsets.py#L457-L470
|
train
|
honzajavorek/redis-collections
|
redis_collections/sortedsets.py
|
GeoDB.places_within_radius
|
def places_within_radius(
self, place=None, latitude=None, longitude=None, radius=0, **kwargs
):
"""
Return descriptions of the places stored in the collection that are
within the circle specified by the given location and radius.
A list of dicts will be returned.
The center of the circle can be specified by the identifier of another
place in the collection with the *place* keyword argument.
Or, it can be specified by using both the *latitude* and *longitude*
keyword arguments.
By default the *radius* is given in kilometers, but you may also set
the *unit* keyword argument to ``'m'``, ``'mi'``, or ``'ft'``.
Limit the number of results returned with the *count* keyword argument.
Change the sorted order by setting the *sort* keyword argument to
``b'DESC'``.
"""
kwargs['withdist'] = True
kwargs['withcoord'] = True
kwargs['withhash'] = False
kwargs.setdefault('sort', 'ASC')
unit = kwargs.setdefault('unit', 'km')
# Make the query
if place is not None:
response = self.redis.georadiusbymember(
self.key, self._pickle(place), radius, **kwargs
)
elif (latitude is not None) and (longitude is not None):
response = self.redis.georadius(
self.key, longitude, latitude, radius, **kwargs
)
else:
raise ValueError(
'Must specify place, or both latitude and longitude'
)
# Assemble the result
ret = []
for item in response:
ret.append(
{
'place': self._unpickle(item[0]),
'distance': item[1],
'unit': unit,
'latitude': item[2][1],
'longitude': item[2][0],
}
)
return ret
|
python
|
def places_within_radius(
self, place=None, latitude=None, longitude=None, radius=0, **kwargs
):
"""
Return descriptions of the places stored in the collection that are
within the circle specified by the given location and radius.
A list of dicts will be returned.
The center of the circle can be specified by the identifier of another
place in the collection with the *place* keyword argument.
Or, it can be specified by using both the *latitude* and *longitude*
keyword arguments.
By default the *radius* is given in kilometers, but you may also set
the *unit* keyword argument to ``'m'``, ``'mi'``, or ``'ft'``.
Limit the number of results returned with the *count* keyword argument.
Change the sorted order by setting the *sort* keyword argument to
``b'DESC'``.
"""
kwargs['withdist'] = True
kwargs['withcoord'] = True
kwargs['withhash'] = False
kwargs.setdefault('sort', 'ASC')
unit = kwargs.setdefault('unit', 'km')
# Make the query
if place is not None:
response = self.redis.georadiusbymember(
self.key, self._pickle(place), radius, **kwargs
)
elif (latitude is not None) and (longitude is not None):
response = self.redis.georadius(
self.key, longitude, latitude, radius, **kwargs
)
else:
raise ValueError(
'Must specify place, or both latitude and longitude'
)
# Assemble the result
ret = []
for item in response:
ret.append(
{
'place': self._unpickle(item[0]),
'distance': item[1],
'unit': unit,
'latitude': item[2][1],
'longitude': item[2][0],
}
)
return ret
|
[
"def",
"places_within_radius",
"(",
"self",
",",
"place",
"=",
"None",
",",
"latitude",
"=",
"None",
",",
"longitude",
"=",
"None",
",",
"radius",
"=",
"0",
",",
"*",
"*",
"kwargs",
")",
":",
"kwargs",
"[",
"'withdist'",
"]",
"=",
"True",
"kwargs",
"[",
"'withcoord'",
"]",
"=",
"True",
"kwargs",
"[",
"'withhash'",
"]",
"=",
"False",
"kwargs",
".",
"setdefault",
"(",
"'sort'",
",",
"'ASC'",
")",
"unit",
"=",
"kwargs",
".",
"setdefault",
"(",
"'unit'",
",",
"'km'",
")",
"# Make the query",
"if",
"place",
"is",
"not",
"None",
":",
"response",
"=",
"self",
".",
"redis",
".",
"georadiusbymember",
"(",
"self",
".",
"key",
",",
"self",
".",
"_pickle",
"(",
"place",
")",
",",
"radius",
",",
"*",
"*",
"kwargs",
")",
"elif",
"(",
"latitude",
"is",
"not",
"None",
")",
"and",
"(",
"longitude",
"is",
"not",
"None",
")",
":",
"response",
"=",
"self",
".",
"redis",
".",
"georadius",
"(",
"self",
".",
"key",
",",
"longitude",
",",
"latitude",
",",
"radius",
",",
"*",
"*",
"kwargs",
")",
"else",
":",
"raise",
"ValueError",
"(",
"'Must specify place, or both latitude and longitude'",
")",
"# Assemble the result",
"ret",
"=",
"[",
"]",
"for",
"item",
"in",
"response",
":",
"ret",
".",
"append",
"(",
"{",
"'place'",
":",
"self",
".",
"_unpickle",
"(",
"item",
"[",
"0",
"]",
")",
",",
"'distance'",
":",
"item",
"[",
"1",
"]",
",",
"'unit'",
":",
"unit",
",",
"'latitude'",
":",
"item",
"[",
"2",
"]",
"[",
"1",
"]",
",",
"'longitude'",
":",
"item",
"[",
"2",
"]",
"[",
"0",
"]",
",",
"}",
")",
"return",
"ret"
] |
Return descriptions of the places stored in the collection that are
within the circle specified by the given location and radius.
A list of dicts will be returned.
The center of the circle can be specified by the identifier of another
place in the collection with the *place* keyword argument.
Or, it can be specified by using both the *latitude* and *longitude*
keyword arguments.
By default the *radius* is given in kilometers, but you may also set
the *unit* keyword argument to ``'m'``, ``'mi'``, or ``'ft'``.
Limit the number of results returned with the *count* keyword argument.
Change the sorted order by setting the *sort* keyword argument to
``b'DESC'``.
|
[
"Return",
"descriptions",
"of",
"the",
"places",
"stored",
"in",
"the",
"collection",
"that",
"are",
"within",
"the",
"circle",
"specified",
"by",
"the",
"given",
"location",
"and",
"radius",
".",
"A",
"list",
"of",
"dicts",
"will",
"be",
"returned",
"."
] |
07ca8efe88fb128f7dc7319dfa6a26cd39b3776b
|
https://github.com/honzajavorek/redis-collections/blob/07ca8efe88fb128f7dc7319dfa6a26cd39b3776b/redis_collections/sortedsets.py#L472-L526
|
train
|
honzajavorek/redis-collections
|
redis_collections/sortedsets.py
|
GeoDB.set_location
|
def set_location(self, place, latitude, longitude, pipe=None):
"""
Set the location of *place* to the location specified by
*latitude* and *longitude*.
*place* can be any pickle-able Python object.
"""
pipe = self.redis if pipe is None else pipe
pipe.geoadd(self.key, longitude, latitude, self._pickle(place))
|
python
|
def set_location(self, place, latitude, longitude, pipe=None):
"""
Set the location of *place* to the location specified by
*latitude* and *longitude*.
*place* can be any pickle-able Python object.
"""
pipe = self.redis if pipe is None else pipe
pipe.geoadd(self.key, longitude, latitude, self._pickle(place))
|
[
"def",
"set_location",
"(",
"self",
",",
"place",
",",
"latitude",
",",
"longitude",
",",
"pipe",
"=",
"None",
")",
":",
"pipe",
"=",
"self",
".",
"redis",
"if",
"pipe",
"is",
"None",
"else",
"pipe",
"pipe",
".",
"geoadd",
"(",
"self",
".",
"key",
",",
"longitude",
",",
"latitude",
",",
"self",
".",
"_pickle",
"(",
"place",
")",
")"
] |
Set the location of *place* to the location specified by
*latitude* and *longitude*.
*place* can be any pickle-able Python object.
|
[
"Set",
"the",
"location",
"of",
"*",
"place",
"*",
"to",
"the",
"location",
"specified",
"by",
"*",
"latitude",
"*",
"and",
"*",
"longitude",
"*",
"."
] |
07ca8efe88fb128f7dc7319dfa6a26cd39b3776b
|
https://github.com/honzajavorek/redis-collections/blob/07ca8efe88fb128f7dc7319dfa6a26cd39b3776b/redis_collections/sortedsets.py#L528-L536
|
train
|
honzajavorek/redis-collections
|
redis_collections/sortedsets.py
|
GeoDB.update
|
def update(self, other):
"""
Update the collection with items from *other*. Accepts other
:class:`GeoDB` instances, dictionaries mapping places to
``{'latitude': latitude, 'longitude': longitude}`` dicts,
or sequences of ``(place, latitude, longitude)`` tuples.
"""
# other is another Sorted Set
def update_sortedset_trans(pipe):
items = other._data(pipe=pipe) if use_redis else other._data()
pipe.multi()
for member, score in items:
pipe.zadd(self.key, {self._pickle(member): float(score)})
# other is dict-like
def update_mapping_trans(pipe):
items = other.items(pipe=pipe) if use_redis else other.items()
pipe.multi()
for place, value in items:
self.set_location(
place, value['latitude'], value['longitude'], pipe=pipe
)
# other is a list of tuples
def update_tuples_trans(pipe):
items = (
other.__iter__(pipe=pipe) if use_redis else other.__iter__()
)
pipe.multi()
for place, latitude, longitude in items:
self.set_location(place, latitude, longitude, pipe=pipe)
watches = []
if self._same_redis(other, RedisCollection):
use_redis = True
watches.append(other.key)
else:
use_redis = False
if isinstance(other, SortedSetBase):
func = update_sortedset_trans
elif hasattr(other, 'items'):
func = update_mapping_trans
elif hasattr(other, '__iter__'):
func = update_tuples_trans
self._transaction(func, *watches)
|
python
|
def update(self, other):
"""
Update the collection with items from *other*. Accepts other
:class:`GeoDB` instances, dictionaries mapping places to
``{'latitude': latitude, 'longitude': longitude}`` dicts,
or sequences of ``(place, latitude, longitude)`` tuples.
"""
# other is another Sorted Set
def update_sortedset_trans(pipe):
items = other._data(pipe=pipe) if use_redis else other._data()
pipe.multi()
for member, score in items:
pipe.zadd(self.key, {self._pickle(member): float(score)})
# other is dict-like
def update_mapping_trans(pipe):
items = other.items(pipe=pipe) if use_redis else other.items()
pipe.multi()
for place, value in items:
self.set_location(
place, value['latitude'], value['longitude'], pipe=pipe
)
# other is a list of tuples
def update_tuples_trans(pipe):
items = (
other.__iter__(pipe=pipe) if use_redis else other.__iter__()
)
pipe.multi()
for place, latitude, longitude in items:
self.set_location(place, latitude, longitude, pipe=pipe)
watches = []
if self._same_redis(other, RedisCollection):
use_redis = True
watches.append(other.key)
else:
use_redis = False
if isinstance(other, SortedSetBase):
func = update_sortedset_trans
elif hasattr(other, 'items'):
func = update_mapping_trans
elif hasattr(other, '__iter__'):
func = update_tuples_trans
self._transaction(func, *watches)
|
[
"def",
"update",
"(",
"self",
",",
"other",
")",
":",
"# other is another Sorted Set",
"def",
"update_sortedset_trans",
"(",
"pipe",
")",
":",
"items",
"=",
"other",
".",
"_data",
"(",
"pipe",
"=",
"pipe",
")",
"if",
"use_redis",
"else",
"other",
".",
"_data",
"(",
")",
"pipe",
".",
"multi",
"(",
")",
"for",
"member",
",",
"score",
"in",
"items",
":",
"pipe",
".",
"zadd",
"(",
"self",
".",
"key",
",",
"{",
"self",
".",
"_pickle",
"(",
"member",
")",
":",
"float",
"(",
"score",
")",
"}",
")",
"# other is dict-like",
"def",
"update_mapping_trans",
"(",
"pipe",
")",
":",
"items",
"=",
"other",
".",
"items",
"(",
"pipe",
"=",
"pipe",
")",
"if",
"use_redis",
"else",
"other",
".",
"items",
"(",
")",
"pipe",
".",
"multi",
"(",
")",
"for",
"place",
",",
"value",
"in",
"items",
":",
"self",
".",
"set_location",
"(",
"place",
",",
"value",
"[",
"'latitude'",
"]",
",",
"value",
"[",
"'longitude'",
"]",
",",
"pipe",
"=",
"pipe",
")",
"# other is a list of tuples",
"def",
"update_tuples_trans",
"(",
"pipe",
")",
":",
"items",
"=",
"(",
"other",
".",
"__iter__",
"(",
"pipe",
"=",
"pipe",
")",
"if",
"use_redis",
"else",
"other",
".",
"__iter__",
"(",
")",
")",
"pipe",
".",
"multi",
"(",
")",
"for",
"place",
",",
"latitude",
",",
"longitude",
"in",
"items",
":",
"self",
".",
"set_location",
"(",
"place",
",",
"latitude",
",",
"longitude",
",",
"pipe",
"=",
"pipe",
")",
"watches",
"=",
"[",
"]",
"if",
"self",
".",
"_same_redis",
"(",
"other",
",",
"RedisCollection",
")",
":",
"use_redis",
"=",
"True",
"watches",
".",
"append",
"(",
"other",
".",
"key",
")",
"else",
":",
"use_redis",
"=",
"False",
"if",
"isinstance",
"(",
"other",
",",
"SortedSetBase",
")",
":",
"func",
"=",
"update_sortedset_trans",
"elif",
"hasattr",
"(",
"other",
",",
"'items'",
")",
":",
"func",
"=",
"update_mapping_trans",
"elif",
"hasattr",
"(",
"other",
",",
"'__iter__'",
")",
":",
"func",
"=",
"update_tuples_trans",
"self",
".",
"_transaction",
"(",
"func",
",",
"*",
"watches",
")"
] |
Update the collection with items from *other*. Accepts other
:class:`GeoDB` instances, dictionaries mapping places to
``{'latitude': latitude, 'longitude': longitude}`` dicts,
or sequences of ``(place, latitude, longitude)`` tuples.
|
[
"Update",
"the",
"collection",
"with",
"items",
"from",
"*",
"other",
"*",
".",
"Accepts",
"other",
":",
"class",
":",
"GeoDB",
"instances",
"dictionaries",
"mapping",
"places",
"to",
"{",
"latitude",
":",
"latitude",
"longitude",
":",
"longitude",
"}",
"dicts",
"or",
"sequences",
"of",
"(",
"place",
"latitude",
"longitude",
")",
"tuples",
"."
] |
07ca8efe88fb128f7dc7319dfa6a26cd39b3776b
|
https://github.com/honzajavorek/redis-collections/blob/07ca8efe88fb128f7dc7319dfa6a26cd39b3776b/redis_collections/sortedsets.py#L538-L587
|
train
|
honzajavorek/redis-collections
|
redis_collections/syncable.py
|
LRUDict.copy
|
def copy(self, key=None):
"""
Creates another collection with the same items and maxsize with
the given *key*.
"""
other = self.__class__(
maxsize=self.maxsize, redis=self.persistence.redis, key=key
)
other.update(self)
return other
|
python
|
def copy(self, key=None):
"""
Creates another collection with the same items and maxsize with
the given *key*.
"""
other = self.__class__(
maxsize=self.maxsize, redis=self.persistence.redis, key=key
)
other.update(self)
return other
|
[
"def",
"copy",
"(",
"self",
",",
"key",
"=",
"None",
")",
":",
"other",
"=",
"self",
".",
"__class__",
"(",
"maxsize",
"=",
"self",
".",
"maxsize",
",",
"redis",
"=",
"self",
".",
"persistence",
".",
"redis",
",",
"key",
"=",
"key",
")",
"other",
".",
"update",
"(",
"self",
")",
"return",
"other"
] |
Creates another collection with the same items and maxsize with
the given *key*.
|
[
"Creates",
"another",
"collection",
"with",
"the",
"same",
"items",
"and",
"maxsize",
"with",
"the",
"given",
"*",
"key",
"*",
"."
] |
07ca8efe88fb128f7dc7319dfa6a26cd39b3776b
|
https://github.com/honzajavorek/redis-collections/blob/07ca8efe88fb128f7dc7319dfa6a26cd39b3776b/redis_collections/syncable.py#L267-L277
|
train
|
honzajavorek/redis-collections
|
redis_collections/syncable.py
|
LRUDict.fromkeys
|
def fromkeys(cls, seq, value=None, **kwargs):
"""
Create a new collection with keys from *seq* and values set to
*value*. The keyword arguments are passed to the persistent ``Dict``.
"""
other = cls(**kwargs)
other.update(((key, value) for key in seq))
return other
|
python
|
def fromkeys(cls, seq, value=None, **kwargs):
"""
Create a new collection with keys from *seq* and values set to
*value*. The keyword arguments are passed to the persistent ``Dict``.
"""
other = cls(**kwargs)
other.update(((key, value) for key in seq))
return other
|
[
"def",
"fromkeys",
"(",
"cls",
",",
"seq",
",",
"value",
"=",
"None",
",",
"*",
"*",
"kwargs",
")",
":",
"other",
"=",
"cls",
"(",
"*",
"*",
"kwargs",
")",
"other",
".",
"update",
"(",
"(",
"(",
"key",
",",
"value",
")",
"for",
"key",
"in",
"seq",
")",
")",
"return",
"other"
] |
Create a new collection with keys from *seq* and values set to
*value*. The keyword arguments are passed to the persistent ``Dict``.
|
[
"Create",
"a",
"new",
"collection",
"with",
"keys",
"from",
"*",
"seq",
"*",
"and",
"values",
"set",
"to",
"*",
"value",
"*",
".",
"The",
"keyword",
"arguments",
"are",
"passed",
"to",
"the",
"persistent",
"Dict",
"."
] |
07ca8efe88fb128f7dc7319dfa6a26cd39b3776b
|
https://github.com/honzajavorek/redis-collections/blob/07ca8efe88fb128f7dc7319dfa6a26cd39b3776b/redis_collections/syncable.py#L280-L288
|
train
|
honzajavorek/redis-collections
|
redis_collections/syncable.py
|
LRUDict.sync
|
def sync(self, clear_cache=False):
"""
Copy items from the local cache to the persistent Dict.
If *clear_cache* is ``True``, clear out the local cache after
pushing its items to Redis.
"""
self.persistence.update(self)
if clear_cache:
self.cache.clear()
|
python
|
def sync(self, clear_cache=False):
"""
Copy items from the local cache to the persistent Dict.
If *clear_cache* is ``True``, clear out the local cache after
pushing its items to Redis.
"""
self.persistence.update(self)
if clear_cache:
self.cache.clear()
|
[
"def",
"sync",
"(",
"self",
",",
"clear_cache",
"=",
"False",
")",
":",
"self",
".",
"persistence",
".",
"update",
"(",
"self",
")",
"if",
"clear_cache",
":",
"self",
".",
"cache",
".",
"clear",
"(",
")"
] |
Copy items from the local cache to the persistent Dict.
If *clear_cache* is ``True``, clear out the local cache after
pushing its items to Redis.
|
[
"Copy",
"items",
"from",
"the",
"local",
"cache",
"to",
"the",
"persistent",
"Dict",
".",
"If",
"*",
"clear_cache",
"*",
"is",
"True",
"clear",
"out",
"the",
"local",
"cache",
"after",
"pushing",
"its",
"items",
"to",
"Redis",
"."
] |
07ca8efe88fb128f7dc7319dfa6a26cd39b3776b
|
https://github.com/honzajavorek/redis-collections/blob/07ca8efe88fb128f7dc7319dfa6a26cd39b3776b/redis_collections/syncable.py#L290-L299
|
train
|
honzajavorek/redis-collections
|
redis_collections/lists.py
|
List._data
|
def _data(self, pipe=None):
"""
Return a :obj:`list` of all values from Redis
(without checking the local cache).
"""
pipe = self.redis if pipe is None else pipe
return [self._unpickle(v) for v in pipe.lrange(self.key, 0, -1)]
|
python
|
def _data(self, pipe=None):
"""
Return a :obj:`list` of all values from Redis
(without checking the local cache).
"""
pipe = self.redis if pipe is None else pipe
return [self._unpickle(v) for v in pipe.lrange(self.key, 0, -1)]
|
[
"def",
"_data",
"(",
"self",
",",
"pipe",
"=",
"None",
")",
":",
"pipe",
"=",
"self",
".",
"redis",
"if",
"pipe",
"is",
"None",
"else",
"pipe",
"return",
"[",
"self",
".",
"_unpickle",
"(",
"v",
")",
"for",
"v",
"in",
"pipe",
".",
"lrange",
"(",
"self",
".",
"key",
",",
"0",
",",
"-",
"1",
")",
"]"
] |
Return a :obj:`list` of all values from Redis
(without checking the local cache).
|
[
"Return",
"a",
":",
"obj",
":",
"list",
"of",
"all",
"values",
"from",
"Redis",
"(",
"without",
"checking",
"the",
"local",
"cache",
")",
"."
] |
07ca8efe88fb128f7dc7319dfa6a26cd39b3776b
|
https://github.com/honzajavorek/redis-collections/blob/07ca8efe88fb128f7dc7319dfa6a26cd39b3776b/redis_collections/lists.py#L245-L251
|
train
|
honzajavorek/redis-collections
|
redis_collections/lists.py
|
List.append
|
def append(self, value):
"""Insert *value* at the end of this collection."""
len_self = self.redis.rpush(self.key, self._pickle(value))
if self.writeback:
self.cache[len_self - 1] = value
|
python
|
def append(self, value):
"""Insert *value* at the end of this collection."""
len_self = self.redis.rpush(self.key, self._pickle(value))
if self.writeback:
self.cache[len_self - 1] = value
|
[
"def",
"append",
"(",
"self",
",",
"value",
")",
":",
"len_self",
"=",
"self",
".",
"redis",
".",
"rpush",
"(",
"self",
".",
"key",
",",
"self",
".",
"_pickle",
"(",
"value",
")",
")",
"if",
"self",
".",
"writeback",
":",
"self",
".",
"cache",
"[",
"len_self",
"-",
"1",
"]",
"=",
"value"
] |
Insert *value* at the end of this collection.
|
[
"Insert",
"*",
"value",
"*",
"at",
"the",
"end",
"of",
"this",
"collection",
"."
] |
07ca8efe88fb128f7dc7319dfa6a26cd39b3776b
|
https://github.com/honzajavorek/redis-collections/blob/07ca8efe88fb128f7dc7319dfa6a26cd39b3776b/redis_collections/lists.py#L338-L343
|
train
|
honzajavorek/redis-collections
|
redis_collections/lists.py
|
List.copy
|
def copy(self, key=None):
"""
Return a new collection with the same items as this one.
If *key* is specified, create the new collection with the given
Redis key.
"""
other = self.__class__(
redis=self.redis, key=key, writeback=self.writeback
)
other.extend(self)
return other
|
python
|
def copy(self, key=None):
"""
Return a new collection with the same items as this one.
If *key* is specified, create the new collection with the given
Redis key.
"""
other = self.__class__(
redis=self.redis, key=key, writeback=self.writeback
)
other.extend(self)
return other
|
[
"def",
"copy",
"(",
"self",
",",
"key",
"=",
"None",
")",
":",
"other",
"=",
"self",
".",
"__class__",
"(",
"redis",
"=",
"self",
".",
"redis",
",",
"key",
"=",
"key",
",",
"writeback",
"=",
"self",
".",
"writeback",
")",
"other",
".",
"extend",
"(",
"self",
")",
"return",
"other"
] |
Return a new collection with the same items as this one.
If *key* is specified, create the new collection with the given
Redis key.
|
[
"Return",
"a",
"new",
"collection",
"with",
"the",
"same",
"items",
"as",
"this",
"one",
".",
"If",
"*",
"key",
"*",
"is",
"specified",
"create",
"the",
"new",
"collection",
"with",
"the",
"given",
"Redis",
"key",
"."
] |
07ca8efe88fb128f7dc7319dfa6a26cd39b3776b
|
https://github.com/honzajavorek/redis-collections/blob/07ca8efe88fb128f7dc7319dfa6a26cd39b3776b/redis_collections/lists.py#L352-L363
|
train
|
honzajavorek/redis-collections
|
redis_collections/lists.py
|
List.extend
|
def extend(self, other):
"""
Adds the values from the iterable *other* to the end of this
collection.
"""
def extend_trans(pipe):
values = list(other.__iter__(pipe)) if use_redis else other
len_self = pipe.rpush(self.key, *(self._pickle(v) for v in values))
if self.writeback:
for i, v in enumerate(values, len_self - len(values)):
self.cache[i] = v
if self._same_redis(other, RedisCollection):
use_redis = True
self._transaction(extend_trans, other.key)
else:
use_redis = False
self._transaction(extend_trans)
|
python
|
def extend(self, other):
"""
Adds the values from the iterable *other* to the end of this
collection.
"""
def extend_trans(pipe):
values = list(other.__iter__(pipe)) if use_redis else other
len_self = pipe.rpush(self.key, *(self._pickle(v) for v in values))
if self.writeback:
for i, v in enumerate(values, len_self - len(values)):
self.cache[i] = v
if self._same_redis(other, RedisCollection):
use_redis = True
self._transaction(extend_trans, other.key)
else:
use_redis = False
self._transaction(extend_trans)
|
[
"def",
"extend",
"(",
"self",
",",
"other",
")",
":",
"def",
"extend_trans",
"(",
"pipe",
")",
":",
"values",
"=",
"list",
"(",
"other",
".",
"__iter__",
"(",
"pipe",
")",
")",
"if",
"use_redis",
"else",
"other",
"len_self",
"=",
"pipe",
".",
"rpush",
"(",
"self",
".",
"key",
",",
"*",
"(",
"self",
".",
"_pickle",
"(",
"v",
")",
"for",
"v",
"in",
"values",
")",
")",
"if",
"self",
".",
"writeback",
":",
"for",
"i",
",",
"v",
"in",
"enumerate",
"(",
"values",
",",
"len_self",
"-",
"len",
"(",
"values",
")",
")",
":",
"self",
".",
"cache",
"[",
"i",
"]",
"=",
"v",
"if",
"self",
".",
"_same_redis",
"(",
"other",
",",
"RedisCollection",
")",
":",
"use_redis",
"=",
"True",
"self",
".",
"_transaction",
"(",
"extend_trans",
",",
"other",
".",
"key",
")",
"else",
":",
"use_redis",
"=",
"False",
"self",
".",
"_transaction",
"(",
"extend_trans",
")"
] |
Adds the values from the iterable *other* to the end of this
collection.
|
[
"Adds",
"the",
"values",
"from",
"the",
"iterable",
"*",
"other",
"*",
"to",
"the",
"end",
"of",
"this",
"collection",
"."
] |
07ca8efe88fb128f7dc7319dfa6a26cd39b3776b
|
https://github.com/honzajavorek/redis-collections/blob/07ca8efe88fb128f7dc7319dfa6a26cd39b3776b/redis_collections/lists.py#L374-L391
|
train
|
honzajavorek/redis-collections
|
redis_collections/lists.py
|
List.index
|
def index(self, value, start=None, stop=None):
"""
Return the index of the first occurence of *value*.
If *start* or *stop* are provided, return the smallest
index such that ``s[index] == value`` and ``start <= index < stop``.
"""
def index_trans(pipe):
len_self, normal_start = self._normalize_index(start or 0, pipe)
__, normal_stop = self._normalize_index(stop or len_self, pipe)
for i, v in enumerate(self.__iter__(pipe=pipe)):
if v == value:
if i < normal_start:
continue
if i >= normal_stop:
break
return i
raise ValueError
return self._transaction(index_trans)
|
python
|
def index(self, value, start=None, stop=None):
"""
Return the index of the first occurence of *value*.
If *start* or *stop* are provided, return the smallest
index such that ``s[index] == value`` and ``start <= index < stop``.
"""
def index_trans(pipe):
len_self, normal_start = self._normalize_index(start or 0, pipe)
__, normal_stop = self._normalize_index(stop or len_self, pipe)
for i, v in enumerate(self.__iter__(pipe=pipe)):
if v == value:
if i < normal_start:
continue
if i >= normal_stop:
break
return i
raise ValueError
return self._transaction(index_trans)
|
[
"def",
"index",
"(",
"self",
",",
"value",
",",
"start",
"=",
"None",
",",
"stop",
"=",
"None",
")",
":",
"def",
"index_trans",
"(",
"pipe",
")",
":",
"len_self",
",",
"normal_start",
"=",
"self",
".",
"_normalize_index",
"(",
"start",
"or",
"0",
",",
"pipe",
")",
"__",
",",
"normal_stop",
"=",
"self",
".",
"_normalize_index",
"(",
"stop",
"or",
"len_self",
",",
"pipe",
")",
"for",
"i",
",",
"v",
"in",
"enumerate",
"(",
"self",
".",
"__iter__",
"(",
"pipe",
"=",
"pipe",
")",
")",
":",
"if",
"v",
"==",
"value",
":",
"if",
"i",
"<",
"normal_start",
":",
"continue",
"if",
"i",
">=",
"normal_stop",
":",
"break",
"return",
"i",
"raise",
"ValueError",
"return",
"self",
".",
"_transaction",
"(",
"index_trans",
")"
] |
Return the index of the first occurence of *value*.
If *start* or *stop* are provided, return the smallest
index such that ``s[index] == value`` and ``start <= index < stop``.
|
[
"Return",
"the",
"index",
"of",
"the",
"first",
"occurence",
"of",
"*",
"value",
"*",
".",
"If",
"*",
"start",
"*",
"or",
"*",
"stop",
"*",
"are",
"provided",
"return",
"the",
"smallest",
"index",
"such",
"that",
"s",
"[",
"index",
"]",
"==",
"value",
"and",
"start",
"<",
"=",
"index",
"<",
"stop",
"."
] |
07ca8efe88fb128f7dc7319dfa6a26cd39b3776b
|
https://github.com/honzajavorek/redis-collections/blob/07ca8efe88fb128f7dc7319dfa6a26cd39b3776b/redis_collections/lists.py#L393-L411
|
train
|
honzajavorek/redis-collections
|
redis_collections/lists.py
|
List.insert
|
def insert(self, index, value):
"""
Insert *value* into the collection at *index*.
"""
if index == 0:
return self._insert_left(value)
def insert_middle_trans(pipe):
self._insert_middle(index, value, pipe=pipe)
return self._transaction(insert_middle_trans)
|
python
|
def insert(self, index, value):
"""
Insert *value* into the collection at *index*.
"""
if index == 0:
return self._insert_left(value)
def insert_middle_trans(pipe):
self._insert_middle(index, value, pipe=pipe)
return self._transaction(insert_middle_trans)
|
[
"def",
"insert",
"(",
"self",
",",
"index",
",",
"value",
")",
":",
"if",
"index",
"==",
"0",
":",
"return",
"self",
".",
"_insert_left",
"(",
"value",
")",
"def",
"insert_middle_trans",
"(",
"pipe",
")",
":",
"self",
".",
"_insert_middle",
"(",
"index",
",",
"value",
",",
"pipe",
"=",
"pipe",
")",
"return",
"self",
".",
"_transaction",
"(",
"insert_middle_trans",
")"
] |
Insert *value* into the collection at *index*.
|
[
"Insert",
"*",
"value",
"*",
"into",
"the",
"collection",
"at",
"*",
"index",
"*",
"."
] |
07ca8efe88fb128f7dc7319dfa6a26cd39b3776b
|
https://github.com/honzajavorek/redis-collections/blob/07ca8efe88fb128f7dc7319dfa6a26cd39b3776b/redis_collections/lists.py#L445-L455
|
train
|
honzajavorek/redis-collections
|
redis_collections/lists.py
|
List.pop
|
def pop(self, index=-1):
"""
Retrieve the value at *index*, remove it from the collection, and
return it.
"""
if index == 0:
return self._pop_left()
elif index == -1:
return self._pop_right()
else:
return self._pop_middle(index)
|
python
|
def pop(self, index=-1):
"""
Retrieve the value at *index*, remove it from the collection, and
return it.
"""
if index == 0:
return self._pop_left()
elif index == -1:
return self._pop_right()
else:
return self._pop_middle(index)
|
[
"def",
"pop",
"(",
"self",
",",
"index",
"=",
"-",
"1",
")",
":",
"if",
"index",
"==",
"0",
":",
"return",
"self",
".",
"_pop_left",
"(",
")",
"elif",
"index",
"==",
"-",
"1",
":",
"return",
"self",
".",
"_pop_right",
"(",
")",
"else",
":",
"return",
"self",
".",
"_pop_middle",
"(",
"index",
")"
] |
Retrieve the value at *index*, remove it from the collection, and
return it.
|
[
"Retrieve",
"the",
"value",
"at",
"*",
"index",
"*",
"remove",
"it",
"from",
"the",
"collection",
"and",
"return",
"it",
"."
] |
07ca8efe88fb128f7dc7319dfa6a26cd39b3776b
|
https://github.com/honzajavorek/redis-collections/blob/07ca8efe88fb128f7dc7319dfa6a26cd39b3776b/redis_collections/lists.py#L457-L467
|
train
|
honzajavorek/redis-collections
|
redis_collections/lists.py
|
List.remove
|
def remove(self, value):
"""Remove the first occurence of *value*."""
def remove_trans(pipe):
# If we're caching, we'll need to synchronize before removing.
if self.writeback:
self._sync_helper(pipe)
delete_count = pipe.lrem(self.key, 1, self._pickle(value))
if delete_count == 0:
raise ValueError
self._transaction(remove_trans)
|
python
|
def remove(self, value):
"""Remove the first occurence of *value*."""
def remove_trans(pipe):
# If we're caching, we'll need to synchronize before removing.
if self.writeback:
self._sync_helper(pipe)
delete_count = pipe.lrem(self.key, 1, self._pickle(value))
if delete_count == 0:
raise ValueError
self._transaction(remove_trans)
|
[
"def",
"remove",
"(",
"self",
",",
"value",
")",
":",
"def",
"remove_trans",
"(",
"pipe",
")",
":",
"# If we're caching, we'll need to synchronize before removing.",
"if",
"self",
".",
"writeback",
":",
"self",
".",
"_sync_helper",
"(",
"pipe",
")",
"delete_count",
"=",
"pipe",
".",
"lrem",
"(",
"self",
".",
"key",
",",
"1",
",",
"self",
".",
"_pickle",
"(",
"value",
")",
")",
"if",
"delete_count",
"==",
"0",
":",
"raise",
"ValueError",
"self",
".",
"_transaction",
"(",
"remove_trans",
")"
] |
Remove the first occurence of *value*.
|
[
"Remove",
"the",
"first",
"occurence",
"of",
"*",
"value",
"*",
"."
] |
07ca8efe88fb128f7dc7319dfa6a26cd39b3776b
|
https://github.com/honzajavorek/redis-collections/blob/07ca8efe88fb128f7dc7319dfa6a26cd39b3776b/redis_collections/lists.py#L469-L480
|
train
|
honzajavorek/redis-collections
|
redis_collections/lists.py
|
List.reverse
|
def reverse(self):
"""
Reverses the items of this collection "in place" (only two values are
retrieved from Redis at a time).
"""
def reverse_trans(pipe):
if self.writeback:
self._sync_helper(pipe)
n = self.__len__(pipe)
for i in range(n // 2):
left = pipe.lindex(self.key, i)
right = pipe.lindex(self.key, n - i - 1)
pipe.lset(self.key, i, right)
pipe.lset(self.key, n - i - 1, left)
self._transaction(reverse_trans)
|
python
|
def reverse(self):
"""
Reverses the items of this collection "in place" (only two values are
retrieved from Redis at a time).
"""
def reverse_trans(pipe):
if self.writeback:
self._sync_helper(pipe)
n = self.__len__(pipe)
for i in range(n // 2):
left = pipe.lindex(self.key, i)
right = pipe.lindex(self.key, n - i - 1)
pipe.lset(self.key, i, right)
pipe.lset(self.key, n - i - 1, left)
self._transaction(reverse_trans)
|
[
"def",
"reverse",
"(",
"self",
")",
":",
"def",
"reverse_trans",
"(",
"pipe",
")",
":",
"if",
"self",
".",
"writeback",
":",
"self",
".",
"_sync_helper",
"(",
"pipe",
")",
"n",
"=",
"self",
".",
"__len__",
"(",
"pipe",
")",
"for",
"i",
"in",
"range",
"(",
"n",
"//",
"2",
")",
":",
"left",
"=",
"pipe",
".",
"lindex",
"(",
"self",
".",
"key",
",",
"i",
")",
"right",
"=",
"pipe",
".",
"lindex",
"(",
"self",
".",
"key",
",",
"n",
"-",
"i",
"-",
"1",
")",
"pipe",
".",
"lset",
"(",
"self",
".",
"key",
",",
"i",
",",
"right",
")",
"pipe",
".",
"lset",
"(",
"self",
".",
"key",
",",
"n",
"-",
"i",
"-",
"1",
",",
"left",
")",
"self",
".",
"_transaction",
"(",
"reverse_trans",
")"
] |
Reverses the items of this collection "in place" (only two values are
retrieved from Redis at a time).
|
[
"Reverses",
"the",
"items",
"of",
"this",
"collection",
"in",
"place",
"(",
"only",
"two",
"values",
"are",
"retrieved",
"from",
"Redis",
"at",
"a",
"time",
")",
"."
] |
07ca8efe88fb128f7dc7319dfa6a26cd39b3776b
|
https://github.com/honzajavorek/redis-collections/blob/07ca8efe88fb128f7dc7319dfa6a26cd39b3776b/redis_collections/lists.py#L482-L498
|
train
|
honzajavorek/redis-collections
|
redis_collections/lists.py
|
List.sort
|
def sort(self, key=None, reverse=False):
"""
Sort the items of this collection according to the optional callable
*key*. If *reverse* is set then the sort order is reversed.
.. note::
This sort requires all items to be retrieved from Redis and stored
in memory.
"""
def sort_trans(pipe):
values = list(self.__iter__(pipe))
values.sort(key=key, reverse=reverse)
pipe.multi()
pipe.delete(self.key)
pipe.rpush(self.key, *(self._pickle(v) for v in values))
if self.writeback:
self.cache = {}
return self._transaction(sort_trans)
|
python
|
def sort(self, key=None, reverse=False):
"""
Sort the items of this collection according to the optional callable
*key*. If *reverse* is set then the sort order is reversed.
.. note::
This sort requires all items to be retrieved from Redis and stored
in memory.
"""
def sort_trans(pipe):
values = list(self.__iter__(pipe))
values.sort(key=key, reverse=reverse)
pipe.multi()
pipe.delete(self.key)
pipe.rpush(self.key, *(self._pickle(v) for v in values))
if self.writeback:
self.cache = {}
return self._transaction(sort_trans)
|
[
"def",
"sort",
"(",
"self",
",",
"key",
"=",
"None",
",",
"reverse",
"=",
"False",
")",
":",
"def",
"sort_trans",
"(",
"pipe",
")",
":",
"values",
"=",
"list",
"(",
"self",
".",
"__iter__",
"(",
"pipe",
")",
")",
"values",
".",
"sort",
"(",
"key",
"=",
"key",
",",
"reverse",
"=",
"reverse",
")",
"pipe",
".",
"multi",
"(",
")",
"pipe",
".",
"delete",
"(",
"self",
".",
"key",
")",
"pipe",
".",
"rpush",
"(",
"self",
".",
"key",
",",
"*",
"(",
"self",
".",
"_pickle",
"(",
"v",
")",
"for",
"v",
"in",
"values",
")",
")",
"if",
"self",
".",
"writeback",
":",
"self",
".",
"cache",
"=",
"{",
"}",
"return",
"self",
".",
"_transaction",
"(",
"sort_trans",
")"
] |
Sort the items of this collection according to the optional callable
*key*. If *reverse* is set then the sort order is reversed.
.. note::
This sort requires all items to be retrieved from Redis and stored
in memory.
|
[
"Sort",
"the",
"items",
"of",
"this",
"collection",
"according",
"to",
"the",
"optional",
"callable",
"*",
"key",
"*",
".",
"If",
"*",
"reverse",
"*",
"is",
"set",
"then",
"the",
"sort",
"order",
"is",
"reversed",
"."
] |
07ca8efe88fb128f7dc7319dfa6a26cd39b3776b
|
https://github.com/honzajavorek/redis-collections/blob/07ca8efe88fb128f7dc7319dfa6a26cd39b3776b/redis_collections/lists.py#L500-L520
|
train
|
honzajavorek/redis-collections
|
redis_collections/lists.py
|
Deque.append
|
def append(self, value):
"""Add *value* to the right side of the collection."""
def append_trans(pipe):
self._append_helper(value, pipe)
self._transaction(append_trans)
|
python
|
def append(self, value):
"""Add *value* to the right side of the collection."""
def append_trans(pipe):
self._append_helper(value, pipe)
self._transaction(append_trans)
|
[
"def",
"append",
"(",
"self",
",",
"value",
")",
":",
"def",
"append_trans",
"(",
"pipe",
")",
":",
"self",
".",
"_append_helper",
"(",
"value",
",",
"pipe",
")",
"self",
".",
"_transaction",
"(",
"append_trans",
")"
] |
Add *value* to the right side of the collection.
|
[
"Add",
"*",
"value",
"*",
"to",
"the",
"right",
"side",
"of",
"the",
"collection",
"."
] |
07ca8efe88fb128f7dc7319dfa6a26cd39b3776b
|
https://github.com/honzajavorek/redis-collections/blob/07ca8efe88fb128f7dc7319dfa6a26cd39b3776b/redis_collections/lists.py#L739-L744
|
train
|
honzajavorek/redis-collections
|
redis_collections/lists.py
|
Deque.appendleft
|
def appendleft(self, value):
"""Add *value* to the left side of the collection."""
def appendleft_trans(pipe):
self._appendleft_helper(value, pipe)
self._transaction(appendleft_trans)
|
python
|
def appendleft(self, value):
"""Add *value* to the left side of the collection."""
def appendleft_trans(pipe):
self._appendleft_helper(value, pipe)
self._transaction(appendleft_trans)
|
[
"def",
"appendleft",
"(",
"self",
",",
"value",
")",
":",
"def",
"appendleft_trans",
"(",
"pipe",
")",
":",
"self",
".",
"_appendleft_helper",
"(",
"value",
",",
"pipe",
")",
"self",
".",
"_transaction",
"(",
"appendleft_trans",
")"
] |
Add *value* to the left side of the collection.
|
[
"Add",
"*",
"value",
"*",
"to",
"the",
"left",
"side",
"of",
"the",
"collection",
"."
] |
07ca8efe88fb128f7dc7319dfa6a26cd39b3776b
|
https://github.com/honzajavorek/redis-collections/blob/07ca8efe88fb128f7dc7319dfa6a26cd39b3776b/redis_collections/lists.py#L764-L769
|
train
|
honzajavorek/redis-collections
|
redis_collections/lists.py
|
Deque.copy
|
def copy(self, key=None):
"""
Return a new collection with the same items as this one.
If *key* is specified, create the new collection with the given
Redis key.
"""
other = self.__class__(
self.__iter__(),
self.maxlen,
redis=self.redis,
key=key,
writeback=self.writeback,
)
return other
|
python
|
def copy(self, key=None):
"""
Return a new collection with the same items as this one.
If *key* is specified, create the new collection with the given
Redis key.
"""
other = self.__class__(
self.__iter__(),
self.maxlen,
redis=self.redis,
key=key,
writeback=self.writeback,
)
return other
|
[
"def",
"copy",
"(",
"self",
",",
"key",
"=",
"None",
")",
":",
"other",
"=",
"self",
".",
"__class__",
"(",
"self",
".",
"__iter__",
"(",
")",
",",
"self",
".",
"maxlen",
",",
"redis",
"=",
"self",
".",
"redis",
",",
"key",
"=",
"key",
",",
"writeback",
"=",
"self",
".",
"writeback",
",",
")",
"return",
"other"
] |
Return a new collection with the same items as this one.
If *key* is specified, create the new collection with the given
Redis key.
|
[
"Return",
"a",
"new",
"collection",
"with",
"the",
"same",
"items",
"as",
"this",
"one",
".",
"If",
"*",
"key",
"*",
"is",
"specified",
"create",
"the",
"new",
"collection",
"with",
"the",
"given",
"Redis",
"key",
"."
] |
07ca8efe88fb128f7dc7319dfa6a26cd39b3776b
|
https://github.com/honzajavorek/redis-collections/blob/07ca8efe88fb128f7dc7319dfa6a26cd39b3776b/redis_collections/lists.py#L771-L785
|
train
|
honzajavorek/redis-collections
|
redis_collections/lists.py
|
Deque.extend
|
def extend(self, other):
"""
Extend the right side of the the collection by appending values from
the iterable *other*.
"""
def extend_trans(pipe):
values = list(other.__iter__(pipe)) if use_redis else other
for v in values:
self._append_helper(v, pipe)
if self._same_redis(other, RedisCollection):
use_redis = True
self._transaction(extend_trans, other.key)
else:
use_redis = False
self._transaction(extend_trans)
|
python
|
def extend(self, other):
"""
Extend the right side of the the collection by appending values from
the iterable *other*.
"""
def extend_trans(pipe):
values = list(other.__iter__(pipe)) if use_redis else other
for v in values:
self._append_helper(v, pipe)
if self._same_redis(other, RedisCollection):
use_redis = True
self._transaction(extend_trans, other.key)
else:
use_redis = False
self._transaction(extend_trans)
|
[
"def",
"extend",
"(",
"self",
",",
"other",
")",
":",
"def",
"extend_trans",
"(",
"pipe",
")",
":",
"values",
"=",
"list",
"(",
"other",
".",
"__iter__",
"(",
"pipe",
")",
")",
"if",
"use_redis",
"else",
"other",
"for",
"v",
"in",
"values",
":",
"self",
".",
"_append_helper",
"(",
"v",
",",
"pipe",
")",
"if",
"self",
".",
"_same_redis",
"(",
"other",
",",
"RedisCollection",
")",
":",
"use_redis",
"=",
"True",
"self",
".",
"_transaction",
"(",
"extend_trans",
",",
"other",
".",
"key",
")",
"else",
":",
"use_redis",
"=",
"False",
"self",
".",
"_transaction",
"(",
"extend_trans",
")"
] |
Extend the right side of the the collection by appending values from
the iterable *other*.
|
[
"Extend",
"the",
"right",
"side",
"of",
"the",
"the",
"collection",
"by",
"appending",
"values",
"from",
"the",
"iterable",
"*",
"other",
"*",
"."
] |
07ca8efe88fb128f7dc7319dfa6a26cd39b3776b
|
https://github.com/honzajavorek/redis-collections/blob/07ca8efe88fb128f7dc7319dfa6a26cd39b3776b/redis_collections/lists.py#L787-L802
|
train
|
honzajavorek/redis-collections
|
redis_collections/lists.py
|
Deque.extendleft
|
def extendleft(self, other):
"""
Extend the left side of the the collection by appending values from
the iterable *other*. Note that the appends will reverse the order
of the given values.
"""
def extendleft_trans(pipe):
values = list(other.__iter__(pipe)) if use_redis else other
for v in values:
self._appendleft_helper(v, pipe)
if self._same_redis(other, RedisCollection):
use_redis = True
self._transaction(extendleft_trans, other.key)
else:
use_redis = False
self._transaction(extendleft_trans)
|
python
|
def extendleft(self, other):
"""
Extend the left side of the the collection by appending values from
the iterable *other*. Note that the appends will reverse the order
of the given values.
"""
def extendleft_trans(pipe):
values = list(other.__iter__(pipe)) if use_redis else other
for v in values:
self._appendleft_helper(v, pipe)
if self._same_redis(other, RedisCollection):
use_redis = True
self._transaction(extendleft_trans, other.key)
else:
use_redis = False
self._transaction(extendleft_trans)
|
[
"def",
"extendleft",
"(",
"self",
",",
"other",
")",
":",
"def",
"extendleft_trans",
"(",
"pipe",
")",
":",
"values",
"=",
"list",
"(",
"other",
".",
"__iter__",
"(",
"pipe",
")",
")",
"if",
"use_redis",
"else",
"other",
"for",
"v",
"in",
"values",
":",
"self",
".",
"_appendleft_helper",
"(",
"v",
",",
"pipe",
")",
"if",
"self",
".",
"_same_redis",
"(",
"other",
",",
"RedisCollection",
")",
":",
"use_redis",
"=",
"True",
"self",
".",
"_transaction",
"(",
"extendleft_trans",
",",
"other",
".",
"key",
")",
"else",
":",
"use_redis",
"=",
"False",
"self",
".",
"_transaction",
"(",
"extendleft_trans",
")"
] |
Extend the left side of the the collection by appending values from
the iterable *other*. Note that the appends will reverse the order
of the given values.
|
[
"Extend",
"the",
"left",
"side",
"of",
"the",
"the",
"collection",
"by",
"appending",
"values",
"from",
"the",
"iterable",
"*",
"other",
"*",
".",
"Note",
"that",
"the",
"appends",
"will",
"reverse",
"the",
"order",
"of",
"the",
"given",
"values",
"."
] |
07ca8efe88fb128f7dc7319dfa6a26cd39b3776b
|
https://github.com/honzajavorek/redis-collections/blob/07ca8efe88fb128f7dc7319dfa6a26cd39b3776b/redis_collections/lists.py#L804-L820
|
train
|
honzajavorek/redis-collections
|
redis_collections/lists.py
|
Deque.insert
|
def insert(self, index, value):
"""
Insert *value* into the collection at *index*.
If the insertion would the collection to grow beyond ``maxlen``,
raise ``IndexError``.
"""
def insert_trans(pipe):
len_self = self.__len__(pipe)
if (self.maxlen is not None) and (len_self >= self.maxlen):
raise IndexError
if index == 0:
self._insert_left(value, pipe)
else:
self._insert_middle(index, value, pipe=pipe)
self._transaction(insert_trans)
|
python
|
def insert(self, index, value):
"""
Insert *value* into the collection at *index*.
If the insertion would the collection to grow beyond ``maxlen``,
raise ``IndexError``.
"""
def insert_trans(pipe):
len_self = self.__len__(pipe)
if (self.maxlen is not None) and (len_self >= self.maxlen):
raise IndexError
if index == 0:
self._insert_left(value, pipe)
else:
self._insert_middle(index, value, pipe=pipe)
self._transaction(insert_trans)
|
[
"def",
"insert",
"(",
"self",
",",
"index",
",",
"value",
")",
":",
"def",
"insert_trans",
"(",
"pipe",
")",
":",
"len_self",
"=",
"self",
".",
"__len__",
"(",
"pipe",
")",
"if",
"(",
"self",
".",
"maxlen",
"is",
"not",
"None",
")",
"and",
"(",
"len_self",
">=",
"self",
".",
"maxlen",
")",
":",
"raise",
"IndexError",
"if",
"index",
"==",
"0",
":",
"self",
".",
"_insert_left",
"(",
"value",
",",
"pipe",
")",
"else",
":",
"self",
".",
"_insert_middle",
"(",
"index",
",",
"value",
",",
"pipe",
"=",
"pipe",
")",
"self",
".",
"_transaction",
"(",
"insert_trans",
")"
] |
Insert *value* into the collection at *index*.
If the insertion would the collection to grow beyond ``maxlen``,
raise ``IndexError``.
|
[
"Insert",
"*",
"value",
"*",
"into",
"the",
"collection",
"at",
"*",
"index",
"*",
".",
"If",
"the",
"insertion",
"would",
"the",
"collection",
"to",
"grow",
"beyond",
"maxlen",
"raise",
"IndexError",
"."
] |
07ca8efe88fb128f7dc7319dfa6a26cd39b3776b
|
https://github.com/honzajavorek/redis-collections/blob/07ca8efe88fb128f7dc7319dfa6a26cd39b3776b/redis_collections/lists.py#L822-L838
|
train
|
honzajavorek/redis-collections
|
redis_collections/lists.py
|
Deque.rotate
|
def rotate(self, n=1):
"""
Rotate the deque n steps to the right.
If n is negative, rotate to the left.
"""
# No work to do for a 0-step rotate
if n == 0:
return
def rotate_trans(pipe):
# Synchronize the cache before rotating
if self.writeback:
self._sync_helper(pipe)
# Rotating len(self) times has no effect.
len_self = self.__len__(pipe)
steps = abs_n % len_self
# When n is positive we can use the built-in Redis command
if forward:
pipe.multi()
for __ in range(steps):
pipe.rpoplpush(self.key, self.key)
# When n is negative we must use Python
else:
for __ in range(steps):
pickled_value = pipe.lpop(self.key)
pipe.rpush(self.key, pickled_value)
forward = n >= 0
abs_n = abs(n)
self._transaction(rotate_trans)
|
python
|
def rotate(self, n=1):
"""
Rotate the deque n steps to the right.
If n is negative, rotate to the left.
"""
# No work to do for a 0-step rotate
if n == 0:
return
def rotate_trans(pipe):
# Synchronize the cache before rotating
if self.writeback:
self._sync_helper(pipe)
# Rotating len(self) times has no effect.
len_self = self.__len__(pipe)
steps = abs_n % len_self
# When n is positive we can use the built-in Redis command
if forward:
pipe.multi()
for __ in range(steps):
pipe.rpoplpush(self.key, self.key)
# When n is negative we must use Python
else:
for __ in range(steps):
pickled_value = pipe.lpop(self.key)
pipe.rpush(self.key, pickled_value)
forward = n >= 0
abs_n = abs(n)
self._transaction(rotate_trans)
|
[
"def",
"rotate",
"(",
"self",
",",
"n",
"=",
"1",
")",
":",
"# No work to do for a 0-step rotate",
"if",
"n",
"==",
"0",
":",
"return",
"def",
"rotate_trans",
"(",
"pipe",
")",
":",
"# Synchronize the cache before rotating",
"if",
"self",
".",
"writeback",
":",
"self",
".",
"_sync_helper",
"(",
"pipe",
")",
"# Rotating len(self) times has no effect.",
"len_self",
"=",
"self",
".",
"__len__",
"(",
"pipe",
")",
"steps",
"=",
"abs_n",
"%",
"len_self",
"# When n is positive we can use the built-in Redis command",
"if",
"forward",
":",
"pipe",
".",
"multi",
"(",
")",
"for",
"__",
"in",
"range",
"(",
"steps",
")",
":",
"pipe",
".",
"rpoplpush",
"(",
"self",
".",
"key",
",",
"self",
".",
"key",
")",
"# When n is negative we must use Python",
"else",
":",
"for",
"__",
"in",
"range",
"(",
"steps",
")",
":",
"pickled_value",
"=",
"pipe",
".",
"lpop",
"(",
"self",
".",
"key",
")",
"pipe",
".",
"rpush",
"(",
"self",
".",
"key",
",",
"pickled_value",
")",
"forward",
"=",
"n",
">=",
"0",
"abs_n",
"=",
"abs",
"(",
"n",
")",
"self",
".",
"_transaction",
"(",
"rotate_trans",
")"
] |
Rotate the deque n steps to the right.
If n is negative, rotate to the left.
|
[
"Rotate",
"the",
"deque",
"n",
"steps",
"to",
"the",
"right",
".",
"If",
"n",
"is",
"negative",
"rotate",
"to",
"the",
"left",
"."
] |
07ca8efe88fb128f7dc7319dfa6a26cd39b3776b
|
https://github.com/honzajavorek/redis-collections/blob/07ca8efe88fb128f7dc7319dfa6a26cd39b3776b/redis_collections/lists.py#L852-L883
|
train
|
ambitioninc/django-entity
|
entity/models.py
|
get_entities_by_kind
|
def get_entities_by_kind(membership_cache=None, is_active=True):
"""
Builds a dict with keys of entity kinds if and values are another dict. Each of these dicts are keyed
off of a super entity id and optional have an 'all' key for any group that has a null super entity.
Example structure:
{
entity_kind_id: {
entity1_id: [1, 2, 3],
entity2_id: [4, 5, 6],
'all': [1, 2, 3, 4, 5, 6]
}
}
:rtype: dict
"""
# Accept an existing cache or build a new one
if membership_cache is None:
membership_cache = EntityGroup.objects.get_membership_cache(is_active=is_active)
entities_by_kind = {}
kinds_with_all = set()
kinds_with_supers = set()
super_ids = set()
# Loop over each group
for group_id, memberships in membership_cache.items():
# Look at each membership
for entity_id, entity_kind_id in memberships:
# Only care about memberships with entity kind
if entity_kind_id:
# Make sure a dict exists for this kind
entities_by_kind.setdefault(entity_kind_id, {})
# Check if this is all entities of a kind under a specific entity
if entity_id:
entities_by_kind[entity_kind_id][entity_id] = []
kinds_with_supers.add(entity_kind_id)
super_ids.add(entity_id)
else:
# This is all entities of this kind
entities_by_kind[entity_kind_id]['all'] = []
kinds_with_all.add(entity_kind_id)
# Get entities for 'all'
all_entities_for_types = Entity.objects.filter(
entity_kind_id__in=kinds_with_all
).values_list('id', 'entity_kind_id')
# Add entity ids to entity kind's all list
for id, entity_kind_id in all_entities_for_types:
entities_by_kind[entity_kind_id]['all'].append(id)
# Get relationships
relationships = EntityRelationship.objects.filter(
super_entity_id__in=super_ids,
sub_entity__entity_kind_id__in=kinds_with_supers
).values_list(
'super_entity_id', 'sub_entity_id', 'sub_entity__entity_kind_id'
)
# Add entity ids to each super entity's list
for super_entity_id, sub_entity_id, sub_entity__entity_kind_id in relationships:
entities_by_kind[sub_entity__entity_kind_id].setdefault(super_entity_id, [])
entities_by_kind[sub_entity__entity_kind_id][super_entity_id].append(sub_entity_id)
return entities_by_kind
|
python
|
def get_entities_by_kind(membership_cache=None, is_active=True):
"""
Builds a dict with keys of entity kinds if and values are another dict. Each of these dicts are keyed
off of a super entity id and optional have an 'all' key for any group that has a null super entity.
Example structure:
{
entity_kind_id: {
entity1_id: [1, 2, 3],
entity2_id: [4, 5, 6],
'all': [1, 2, 3, 4, 5, 6]
}
}
:rtype: dict
"""
# Accept an existing cache or build a new one
if membership_cache is None:
membership_cache = EntityGroup.objects.get_membership_cache(is_active=is_active)
entities_by_kind = {}
kinds_with_all = set()
kinds_with_supers = set()
super_ids = set()
# Loop over each group
for group_id, memberships in membership_cache.items():
# Look at each membership
for entity_id, entity_kind_id in memberships:
# Only care about memberships with entity kind
if entity_kind_id:
# Make sure a dict exists for this kind
entities_by_kind.setdefault(entity_kind_id, {})
# Check if this is all entities of a kind under a specific entity
if entity_id:
entities_by_kind[entity_kind_id][entity_id] = []
kinds_with_supers.add(entity_kind_id)
super_ids.add(entity_id)
else:
# This is all entities of this kind
entities_by_kind[entity_kind_id]['all'] = []
kinds_with_all.add(entity_kind_id)
# Get entities for 'all'
all_entities_for_types = Entity.objects.filter(
entity_kind_id__in=kinds_with_all
).values_list('id', 'entity_kind_id')
# Add entity ids to entity kind's all list
for id, entity_kind_id in all_entities_for_types:
entities_by_kind[entity_kind_id]['all'].append(id)
# Get relationships
relationships = EntityRelationship.objects.filter(
super_entity_id__in=super_ids,
sub_entity__entity_kind_id__in=kinds_with_supers
).values_list(
'super_entity_id', 'sub_entity_id', 'sub_entity__entity_kind_id'
)
# Add entity ids to each super entity's list
for super_entity_id, sub_entity_id, sub_entity__entity_kind_id in relationships:
entities_by_kind[sub_entity__entity_kind_id].setdefault(super_entity_id, [])
entities_by_kind[sub_entity__entity_kind_id][super_entity_id].append(sub_entity_id)
return entities_by_kind
|
[
"def",
"get_entities_by_kind",
"(",
"membership_cache",
"=",
"None",
",",
"is_active",
"=",
"True",
")",
":",
"# Accept an existing cache or build a new one",
"if",
"membership_cache",
"is",
"None",
":",
"membership_cache",
"=",
"EntityGroup",
".",
"objects",
".",
"get_membership_cache",
"(",
"is_active",
"=",
"is_active",
")",
"entities_by_kind",
"=",
"{",
"}",
"kinds_with_all",
"=",
"set",
"(",
")",
"kinds_with_supers",
"=",
"set",
"(",
")",
"super_ids",
"=",
"set",
"(",
")",
"# Loop over each group",
"for",
"group_id",
",",
"memberships",
"in",
"membership_cache",
".",
"items",
"(",
")",
":",
"# Look at each membership",
"for",
"entity_id",
",",
"entity_kind_id",
"in",
"memberships",
":",
"# Only care about memberships with entity kind",
"if",
"entity_kind_id",
":",
"# Make sure a dict exists for this kind",
"entities_by_kind",
".",
"setdefault",
"(",
"entity_kind_id",
",",
"{",
"}",
")",
"# Check if this is all entities of a kind under a specific entity",
"if",
"entity_id",
":",
"entities_by_kind",
"[",
"entity_kind_id",
"]",
"[",
"entity_id",
"]",
"=",
"[",
"]",
"kinds_with_supers",
".",
"add",
"(",
"entity_kind_id",
")",
"super_ids",
".",
"add",
"(",
"entity_id",
")",
"else",
":",
"# This is all entities of this kind",
"entities_by_kind",
"[",
"entity_kind_id",
"]",
"[",
"'all'",
"]",
"=",
"[",
"]",
"kinds_with_all",
".",
"add",
"(",
"entity_kind_id",
")",
"# Get entities for 'all'",
"all_entities_for_types",
"=",
"Entity",
".",
"objects",
".",
"filter",
"(",
"entity_kind_id__in",
"=",
"kinds_with_all",
")",
".",
"values_list",
"(",
"'id'",
",",
"'entity_kind_id'",
")",
"# Add entity ids to entity kind's all list",
"for",
"id",
",",
"entity_kind_id",
"in",
"all_entities_for_types",
":",
"entities_by_kind",
"[",
"entity_kind_id",
"]",
"[",
"'all'",
"]",
".",
"append",
"(",
"id",
")",
"# Get relationships",
"relationships",
"=",
"EntityRelationship",
".",
"objects",
".",
"filter",
"(",
"super_entity_id__in",
"=",
"super_ids",
",",
"sub_entity__entity_kind_id__in",
"=",
"kinds_with_supers",
")",
".",
"values_list",
"(",
"'super_entity_id'",
",",
"'sub_entity_id'",
",",
"'sub_entity__entity_kind_id'",
")",
"# Add entity ids to each super entity's list",
"for",
"super_entity_id",
",",
"sub_entity_id",
",",
"sub_entity__entity_kind_id",
"in",
"relationships",
":",
"entities_by_kind",
"[",
"sub_entity__entity_kind_id",
"]",
".",
"setdefault",
"(",
"super_entity_id",
",",
"[",
"]",
")",
"entities_by_kind",
"[",
"sub_entity__entity_kind_id",
"]",
"[",
"super_entity_id",
"]",
".",
"append",
"(",
"sub_entity_id",
")",
"return",
"entities_by_kind"
] |
Builds a dict with keys of entity kinds if and values are another dict. Each of these dicts are keyed
off of a super entity id and optional have an 'all' key for any group that has a null super entity.
Example structure:
{
entity_kind_id: {
entity1_id: [1, 2, 3],
entity2_id: [4, 5, 6],
'all': [1, 2, 3, 4, 5, 6]
}
}
:rtype: dict
|
[
"Builds",
"a",
"dict",
"with",
"keys",
"of",
"entity",
"kinds",
"if",
"and",
"values",
"are",
"another",
"dict",
".",
"Each",
"of",
"these",
"dicts",
"are",
"keyed",
"off",
"of",
"a",
"super",
"entity",
"id",
"and",
"optional",
"have",
"an",
"all",
"key",
"for",
"any",
"group",
"that",
"has",
"a",
"null",
"super",
"entity",
".",
"Example",
"structure",
":",
"{",
"entity_kind_id",
":",
"{",
"entity1_id",
":",
"[",
"1",
"2",
"3",
"]",
"entity2_id",
":",
"[",
"4",
"5",
"6",
"]",
"all",
":",
"[",
"1",
"2",
"3",
"4",
"5",
"6",
"]",
"}",
"}"
] |
ebc61f34313c52f4ef5819eb1da25b2ad837e80c
|
https://github.com/ambitioninc/django-entity/blob/ebc61f34313c52f4ef5819eb1da25b2ad837e80c/entity/models.py#L543-L611
|
train
|
ambitioninc/django-entity
|
entity/models.py
|
EntityQuerySet.is_sub_to_all
|
def is_sub_to_all(self, *super_entities):
"""
Given a list of super entities, return the entities that have those as a subset of their super entities.
"""
if super_entities:
if len(super_entities) == 1:
# Optimize for the case of just one super entity since this is a much less intensive query
has_subset = EntityRelationship.objects.filter(
super_entity=super_entities[0]).values_list('sub_entity', flat=True)
else:
# Get a list of entities that have super entities with all types
has_subset = EntityRelationship.objects.filter(
super_entity__in=super_entities).values('sub_entity').annotate(Count('super_entity')).filter(
super_entity__count=len(set(super_entities))).values_list('sub_entity', flat=True)
return self.filter(id__in=has_subset)
else:
return self
|
python
|
def is_sub_to_all(self, *super_entities):
"""
Given a list of super entities, return the entities that have those as a subset of their super entities.
"""
if super_entities:
if len(super_entities) == 1:
# Optimize for the case of just one super entity since this is a much less intensive query
has_subset = EntityRelationship.objects.filter(
super_entity=super_entities[0]).values_list('sub_entity', flat=True)
else:
# Get a list of entities that have super entities with all types
has_subset = EntityRelationship.objects.filter(
super_entity__in=super_entities).values('sub_entity').annotate(Count('super_entity')).filter(
super_entity__count=len(set(super_entities))).values_list('sub_entity', flat=True)
return self.filter(id__in=has_subset)
else:
return self
|
[
"def",
"is_sub_to_all",
"(",
"self",
",",
"*",
"super_entities",
")",
":",
"if",
"super_entities",
":",
"if",
"len",
"(",
"super_entities",
")",
"==",
"1",
":",
"# Optimize for the case of just one super entity since this is a much less intensive query",
"has_subset",
"=",
"EntityRelationship",
".",
"objects",
".",
"filter",
"(",
"super_entity",
"=",
"super_entities",
"[",
"0",
"]",
")",
".",
"values_list",
"(",
"'sub_entity'",
",",
"flat",
"=",
"True",
")",
"else",
":",
"# Get a list of entities that have super entities with all types",
"has_subset",
"=",
"EntityRelationship",
".",
"objects",
".",
"filter",
"(",
"super_entity__in",
"=",
"super_entities",
")",
".",
"values",
"(",
"'sub_entity'",
")",
".",
"annotate",
"(",
"Count",
"(",
"'super_entity'",
")",
")",
".",
"filter",
"(",
"super_entity__count",
"=",
"len",
"(",
"set",
"(",
"super_entities",
")",
")",
")",
".",
"values_list",
"(",
"'sub_entity'",
",",
"flat",
"=",
"True",
")",
"return",
"self",
".",
"filter",
"(",
"id__in",
"=",
"has_subset",
")",
"else",
":",
"return",
"self"
] |
Given a list of super entities, return the entities that have those as a subset of their super entities.
|
[
"Given",
"a",
"list",
"of",
"super",
"entities",
"return",
"the",
"entities",
"that",
"have",
"those",
"as",
"a",
"subset",
"of",
"their",
"super",
"entities",
"."
] |
ebc61f34313c52f4ef5819eb1da25b2ad837e80c
|
https://github.com/ambitioninc/django-entity/blob/ebc61f34313c52f4ef5819eb1da25b2ad837e80c/entity/models.py#L79-L96
|
train
|
ambitioninc/django-entity
|
entity/models.py
|
EntityQuerySet.is_sub_to_any
|
def is_sub_to_any(self, *super_entities):
"""
Given a list of super entities, return the entities that have super entities that interset with those provided.
"""
if super_entities:
return self.filter(id__in=EntityRelationship.objects.filter(
super_entity__in=super_entities).values_list('sub_entity', flat=True))
else:
return self
|
python
|
def is_sub_to_any(self, *super_entities):
"""
Given a list of super entities, return the entities that have super entities that interset with those provided.
"""
if super_entities:
return self.filter(id__in=EntityRelationship.objects.filter(
super_entity__in=super_entities).values_list('sub_entity', flat=True))
else:
return self
|
[
"def",
"is_sub_to_any",
"(",
"self",
",",
"*",
"super_entities",
")",
":",
"if",
"super_entities",
":",
"return",
"self",
".",
"filter",
"(",
"id__in",
"=",
"EntityRelationship",
".",
"objects",
".",
"filter",
"(",
"super_entity__in",
"=",
"super_entities",
")",
".",
"values_list",
"(",
"'sub_entity'",
",",
"flat",
"=",
"True",
")",
")",
"else",
":",
"return",
"self"
] |
Given a list of super entities, return the entities that have super entities that interset with those provided.
|
[
"Given",
"a",
"list",
"of",
"super",
"entities",
"return",
"the",
"entities",
"that",
"have",
"super",
"entities",
"that",
"interset",
"with",
"those",
"provided",
"."
] |
ebc61f34313c52f4ef5819eb1da25b2ad837e80c
|
https://github.com/ambitioninc/django-entity/blob/ebc61f34313c52f4ef5819eb1da25b2ad837e80c/entity/models.py#L98-L106
|
train
|
ambitioninc/django-entity
|
entity/models.py
|
EntityQuerySet.is_sub_to_all_kinds
|
def is_sub_to_all_kinds(self, *super_entity_kinds):
"""
Each returned entity will have superentites whos combined entity_kinds included *super_entity_kinds
"""
if super_entity_kinds:
if len(super_entity_kinds) == 1:
# Optimize for the case of just one
has_subset = EntityRelationship.objects.filter(
super_entity__entity_kind=super_entity_kinds[0]).values_list('sub_entity', flat=True)
else:
# Get a list of entities that have super entities with all types
has_subset = EntityRelationship.objects.filter(
super_entity__entity_kind__in=super_entity_kinds).values('sub_entity').annotate(
Count('super_entity')).filter(super_entity__count=len(set(super_entity_kinds))).values_list(
'sub_entity', flat=True)
return self.filter(pk__in=has_subset)
else:
return self
|
python
|
def is_sub_to_all_kinds(self, *super_entity_kinds):
"""
Each returned entity will have superentites whos combined entity_kinds included *super_entity_kinds
"""
if super_entity_kinds:
if len(super_entity_kinds) == 1:
# Optimize for the case of just one
has_subset = EntityRelationship.objects.filter(
super_entity__entity_kind=super_entity_kinds[0]).values_list('sub_entity', flat=True)
else:
# Get a list of entities that have super entities with all types
has_subset = EntityRelationship.objects.filter(
super_entity__entity_kind__in=super_entity_kinds).values('sub_entity').annotate(
Count('super_entity')).filter(super_entity__count=len(set(super_entity_kinds))).values_list(
'sub_entity', flat=True)
return self.filter(pk__in=has_subset)
else:
return self
|
[
"def",
"is_sub_to_all_kinds",
"(",
"self",
",",
"*",
"super_entity_kinds",
")",
":",
"if",
"super_entity_kinds",
":",
"if",
"len",
"(",
"super_entity_kinds",
")",
"==",
"1",
":",
"# Optimize for the case of just one",
"has_subset",
"=",
"EntityRelationship",
".",
"objects",
".",
"filter",
"(",
"super_entity__entity_kind",
"=",
"super_entity_kinds",
"[",
"0",
"]",
")",
".",
"values_list",
"(",
"'sub_entity'",
",",
"flat",
"=",
"True",
")",
"else",
":",
"# Get a list of entities that have super entities with all types",
"has_subset",
"=",
"EntityRelationship",
".",
"objects",
".",
"filter",
"(",
"super_entity__entity_kind__in",
"=",
"super_entity_kinds",
")",
".",
"values",
"(",
"'sub_entity'",
")",
".",
"annotate",
"(",
"Count",
"(",
"'super_entity'",
")",
")",
".",
"filter",
"(",
"super_entity__count",
"=",
"len",
"(",
"set",
"(",
"super_entity_kinds",
")",
")",
")",
".",
"values_list",
"(",
"'sub_entity'",
",",
"flat",
"=",
"True",
")",
"return",
"self",
".",
"filter",
"(",
"pk__in",
"=",
"has_subset",
")",
"else",
":",
"return",
"self"
] |
Each returned entity will have superentites whos combined entity_kinds included *super_entity_kinds
|
[
"Each",
"returned",
"entity",
"will",
"have",
"superentites",
"whos",
"combined",
"entity_kinds",
"included",
"*",
"super_entity_kinds"
] |
ebc61f34313c52f4ef5819eb1da25b2ad837e80c
|
https://github.com/ambitioninc/django-entity/blob/ebc61f34313c52f4ef5819eb1da25b2ad837e80c/entity/models.py#L108-L126
|
train
|
ambitioninc/django-entity
|
entity/models.py
|
EntityQuerySet.is_sub_to_any_kind
|
def is_sub_to_any_kind(self, *super_entity_kinds):
"""
Find all entities that have super_entities of any of the specified kinds
"""
if super_entity_kinds:
# get the pks of the desired subs from the relationships table
if len(super_entity_kinds) == 1:
entity_pks = EntityRelationship.objects.filter(
super_entity__entity_kind=super_entity_kinds[0]
).select_related('entity_kind', 'sub_entity').values_list('sub_entity', flat=True)
else:
entity_pks = EntityRelationship.objects.filter(
super_entity__entity_kind__in=super_entity_kinds
).select_related('entity_kind', 'sub_entity').values_list('sub_entity', flat=True)
# return a queryset limited to only those pks
return self.filter(pk__in=entity_pks)
else:
return self
|
python
|
def is_sub_to_any_kind(self, *super_entity_kinds):
"""
Find all entities that have super_entities of any of the specified kinds
"""
if super_entity_kinds:
# get the pks of the desired subs from the relationships table
if len(super_entity_kinds) == 1:
entity_pks = EntityRelationship.objects.filter(
super_entity__entity_kind=super_entity_kinds[0]
).select_related('entity_kind', 'sub_entity').values_list('sub_entity', flat=True)
else:
entity_pks = EntityRelationship.objects.filter(
super_entity__entity_kind__in=super_entity_kinds
).select_related('entity_kind', 'sub_entity').values_list('sub_entity', flat=True)
# return a queryset limited to only those pks
return self.filter(pk__in=entity_pks)
else:
return self
|
[
"def",
"is_sub_to_any_kind",
"(",
"self",
",",
"*",
"super_entity_kinds",
")",
":",
"if",
"super_entity_kinds",
":",
"# get the pks of the desired subs from the relationships table",
"if",
"len",
"(",
"super_entity_kinds",
")",
"==",
"1",
":",
"entity_pks",
"=",
"EntityRelationship",
".",
"objects",
".",
"filter",
"(",
"super_entity__entity_kind",
"=",
"super_entity_kinds",
"[",
"0",
"]",
")",
".",
"select_related",
"(",
"'entity_kind'",
",",
"'sub_entity'",
")",
".",
"values_list",
"(",
"'sub_entity'",
",",
"flat",
"=",
"True",
")",
"else",
":",
"entity_pks",
"=",
"EntityRelationship",
".",
"objects",
".",
"filter",
"(",
"super_entity__entity_kind__in",
"=",
"super_entity_kinds",
")",
".",
"select_related",
"(",
"'entity_kind'",
",",
"'sub_entity'",
")",
".",
"values_list",
"(",
"'sub_entity'",
",",
"flat",
"=",
"True",
")",
"# return a queryset limited to only those pks",
"return",
"self",
".",
"filter",
"(",
"pk__in",
"=",
"entity_pks",
")",
"else",
":",
"return",
"self"
] |
Find all entities that have super_entities of any of the specified kinds
|
[
"Find",
"all",
"entities",
"that",
"have",
"super_entities",
"of",
"any",
"of",
"the",
"specified",
"kinds"
] |
ebc61f34313c52f4ef5819eb1da25b2ad837e80c
|
https://github.com/ambitioninc/django-entity/blob/ebc61f34313c52f4ef5819eb1da25b2ad837e80c/entity/models.py#L128-L145
|
train
|
ambitioninc/django-entity
|
entity/models.py
|
EntityQuerySet.cache_relationships
|
def cache_relationships(self, cache_super=True, cache_sub=True):
"""
Caches the super and sub relationships by doing a prefetch_related.
"""
relationships_to_cache = compress(
['super_relationships__super_entity', 'sub_relationships__sub_entity'], [cache_super, cache_sub])
return self.prefetch_related(*relationships_to_cache)
|
python
|
def cache_relationships(self, cache_super=True, cache_sub=True):
"""
Caches the super and sub relationships by doing a prefetch_related.
"""
relationships_to_cache = compress(
['super_relationships__super_entity', 'sub_relationships__sub_entity'], [cache_super, cache_sub])
return self.prefetch_related(*relationships_to_cache)
|
[
"def",
"cache_relationships",
"(",
"self",
",",
"cache_super",
"=",
"True",
",",
"cache_sub",
"=",
"True",
")",
":",
"relationships_to_cache",
"=",
"compress",
"(",
"[",
"'super_relationships__super_entity'",
",",
"'sub_relationships__sub_entity'",
"]",
",",
"[",
"cache_super",
",",
"cache_sub",
"]",
")",
"return",
"self",
".",
"prefetch_related",
"(",
"*",
"relationships_to_cache",
")"
] |
Caches the super and sub relationships by doing a prefetch_related.
|
[
"Caches",
"the",
"super",
"and",
"sub",
"relationships",
"by",
"doing",
"a",
"prefetch_related",
"."
] |
ebc61f34313c52f4ef5819eb1da25b2ad837e80c
|
https://github.com/ambitioninc/django-entity/blob/ebc61f34313c52f4ef5819eb1da25b2ad837e80c/entity/models.py#L147-L153
|
train
|
ambitioninc/django-entity
|
entity/models.py
|
AllEntityManager.get_for_obj
|
def get_for_obj(self, entity_model_obj):
"""
Given a saved entity model object, return the associated entity.
"""
return self.get(entity_type=ContentType.objects.get_for_model(
entity_model_obj, for_concrete_model=False), entity_id=entity_model_obj.id)
|
python
|
def get_for_obj(self, entity_model_obj):
"""
Given a saved entity model object, return the associated entity.
"""
return self.get(entity_type=ContentType.objects.get_for_model(
entity_model_obj, for_concrete_model=False), entity_id=entity_model_obj.id)
|
[
"def",
"get_for_obj",
"(",
"self",
",",
"entity_model_obj",
")",
":",
"return",
"self",
".",
"get",
"(",
"entity_type",
"=",
"ContentType",
".",
"objects",
".",
"get_for_model",
"(",
"entity_model_obj",
",",
"for_concrete_model",
"=",
"False",
")",
",",
"entity_id",
"=",
"entity_model_obj",
".",
"id",
")"
] |
Given a saved entity model object, return the associated entity.
|
[
"Given",
"a",
"saved",
"entity",
"model",
"object",
"return",
"the",
"associated",
"entity",
"."
] |
ebc61f34313c52f4ef5819eb1da25b2ad837e80c
|
https://github.com/ambitioninc/django-entity/blob/ebc61f34313c52f4ef5819eb1da25b2ad837e80c/entity/models.py#L163-L168
|
train
|
ambitioninc/django-entity
|
entity/models.py
|
AllEntityManager.delete_for_obj
|
def delete_for_obj(self, entity_model_obj):
"""
Delete the entities associated with a model object.
"""
return self.filter(
entity_type=ContentType.objects.get_for_model(
entity_model_obj, for_concrete_model=False), entity_id=entity_model_obj.id).delete(
force=True)
|
python
|
def delete_for_obj(self, entity_model_obj):
"""
Delete the entities associated with a model object.
"""
return self.filter(
entity_type=ContentType.objects.get_for_model(
entity_model_obj, for_concrete_model=False), entity_id=entity_model_obj.id).delete(
force=True)
|
[
"def",
"delete_for_obj",
"(",
"self",
",",
"entity_model_obj",
")",
":",
"return",
"self",
".",
"filter",
"(",
"entity_type",
"=",
"ContentType",
".",
"objects",
".",
"get_for_model",
"(",
"entity_model_obj",
",",
"for_concrete_model",
"=",
"False",
")",
",",
"entity_id",
"=",
"entity_model_obj",
".",
"id",
")",
".",
"delete",
"(",
"force",
"=",
"True",
")"
] |
Delete the entities associated with a model object.
|
[
"Delete",
"the",
"entities",
"associated",
"with",
"a",
"model",
"object",
"."
] |
ebc61f34313c52f4ef5819eb1da25b2ad837e80c
|
https://github.com/ambitioninc/django-entity/blob/ebc61f34313c52f4ef5819eb1da25b2ad837e80c/entity/models.py#L170-L177
|
train
|
ambitioninc/django-entity
|
entity/models.py
|
AllEntityManager.cache_relationships
|
def cache_relationships(self, cache_super=True, cache_sub=True):
"""
Caches the super and sub relationships by doing a prefetch_related.
"""
return self.get_queryset().cache_relationships(cache_super=cache_super, cache_sub=cache_sub)
|
python
|
def cache_relationships(self, cache_super=True, cache_sub=True):
"""
Caches the super and sub relationships by doing a prefetch_related.
"""
return self.get_queryset().cache_relationships(cache_super=cache_super, cache_sub=cache_sub)
|
[
"def",
"cache_relationships",
"(",
"self",
",",
"cache_super",
"=",
"True",
",",
"cache_sub",
"=",
"True",
")",
":",
"return",
"self",
".",
"get_queryset",
"(",
")",
".",
"cache_relationships",
"(",
"cache_super",
"=",
"cache_super",
",",
"cache_sub",
"=",
"cache_sub",
")"
] |
Caches the super and sub relationships by doing a prefetch_related.
|
[
"Caches",
"the",
"super",
"and",
"sub",
"relationships",
"by",
"doing",
"a",
"prefetch_related",
"."
] |
ebc61f34313c52f4ef5819eb1da25b2ad837e80c
|
https://github.com/ambitioninc/django-entity/blob/ebc61f34313c52f4ef5819eb1da25b2ad837e80c/entity/models.py#L228-L232
|
train
|
ambitioninc/django-entity
|
entity/models.py
|
EntityGroupManager.get_membership_cache
|
def get_membership_cache(self, group_ids=None, is_active=True):
"""
Build a dict cache with the group membership info. Keyed off the group id and the values are
a 2 element list of entity id and entity kind id (same values as the membership model). If no group ids
are passed, then all groups will be fetched
:param is_active: Flag indicating whether to filter on entity active status. None will not filter.
:rtype: dict
"""
membership_queryset = EntityGroupMembership.objects.filter(
Q(entity__isnull=True) | (Q(entity__isnull=False) & Q(entity__is_active=is_active))
)
if is_active is None:
membership_queryset = EntityGroupMembership.objects.all()
if group_ids:
membership_queryset = membership_queryset.filter(entity_group_id__in=group_ids)
membership_queryset = membership_queryset.values_list('entity_group_id', 'entity_id', 'sub_entity_kind_id')
# Iterate over the query results and build the cache dict
membership_cache = {}
for entity_group_id, entity_id, sub_entity_kind_id in membership_queryset:
membership_cache.setdefault(entity_group_id, [])
membership_cache[entity_group_id].append([entity_id, sub_entity_kind_id])
return membership_cache
|
python
|
def get_membership_cache(self, group_ids=None, is_active=True):
"""
Build a dict cache with the group membership info. Keyed off the group id and the values are
a 2 element list of entity id and entity kind id (same values as the membership model). If no group ids
are passed, then all groups will be fetched
:param is_active: Flag indicating whether to filter on entity active status. None will not filter.
:rtype: dict
"""
membership_queryset = EntityGroupMembership.objects.filter(
Q(entity__isnull=True) | (Q(entity__isnull=False) & Q(entity__is_active=is_active))
)
if is_active is None:
membership_queryset = EntityGroupMembership.objects.all()
if group_ids:
membership_queryset = membership_queryset.filter(entity_group_id__in=group_ids)
membership_queryset = membership_queryset.values_list('entity_group_id', 'entity_id', 'sub_entity_kind_id')
# Iterate over the query results and build the cache dict
membership_cache = {}
for entity_group_id, entity_id, sub_entity_kind_id in membership_queryset:
membership_cache.setdefault(entity_group_id, [])
membership_cache[entity_group_id].append([entity_id, sub_entity_kind_id])
return membership_cache
|
[
"def",
"get_membership_cache",
"(",
"self",
",",
"group_ids",
"=",
"None",
",",
"is_active",
"=",
"True",
")",
":",
"membership_queryset",
"=",
"EntityGroupMembership",
".",
"objects",
".",
"filter",
"(",
"Q",
"(",
"entity__isnull",
"=",
"True",
")",
"|",
"(",
"Q",
"(",
"entity__isnull",
"=",
"False",
")",
"&",
"Q",
"(",
"entity__is_active",
"=",
"is_active",
")",
")",
")",
"if",
"is_active",
"is",
"None",
":",
"membership_queryset",
"=",
"EntityGroupMembership",
".",
"objects",
".",
"all",
"(",
")",
"if",
"group_ids",
":",
"membership_queryset",
"=",
"membership_queryset",
".",
"filter",
"(",
"entity_group_id__in",
"=",
"group_ids",
")",
"membership_queryset",
"=",
"membership_queryset",
".",
"values_list",
"(",
"'entity_group_id'",
",",
"'entity_id'",
",",
"'sub_entity_kind_id'",
")",
"# Iterate over the query results and build the cache dict",
"membership_cache",
"=",
"{",
"}",
"for",
"entity_group_id",
",",
"entity_id",
",",
"sub_entity_kind_id",
"in",
"membership_queryset",
":",
"membership_cache",
".",
"setdefault",
"(",
"entity_group_id",
",",
"[",
"]",
")",
"membership_cache",
"[",
"entity_group_id",
"]",
".",
"append",
"(",
"[",
"entity_id",
",",
"sub_entity_kind_id",
"]",
")",
"return",
"membership_cache"
] |
Build a dict cache with the group membership info. Keyed off the group id and the values are
a 2 element list of entity id and entity kind id (same values as the membership model). If no group ids
are passed, then all groups will be fetched
:param is_active: Flag indicating whether to filter on entity active status. None will not filter.
:rtype: dict
|
[
"Build",
"a",
"dict",
"cache",
"with",
"the",
"group",
"membership",
"info",
".",
"Keyed",
"off",
"the",
"group",
"id",
"and",
"the",
"values",
"are",
"a",
"2",
"element",
"list",
"of",
"entity",
"id",
"and",
"entity",
"kind",
"id",
"(",
"same",
"values",
"as",
"the",
"membership",
"model",
")",
".",
"If",
"no",
"group",
"ids",
"are",
"passed",
"then",
"all",
"groups",
"will",
"be",
"fetched"
] |
ebc61f34313c52f4ef5819eb1da25b2ad837e80c
|
https://github.com/ambitioninc/django-entity/blob/ebc61f34313c52f4ef5819eb1da25b2ad837e80c/entity/models.py#L317-L343
|
train
|
ambitioninc/django-entity
|
entity/models.py
|
EntityGroup.all_entities
|
def all_entities(self, is_active=True):
"""
Return all the entities in the group.
Because groups can contain both individual entities, as well
as whole groups of entities, this method acts as a convenient
way to get a queryset of all the entities in the group.
"""
return self.get_all_entities(return_models=True, is_active=is_active)
|
python
|
def all_entities(self, is_active=True):
"""
Return all the entities in the group.
Because groups can contain both individual entities, as well
as whole groups of entities, this method acts as a convenient
way to get a queryset of all the entities in the group.
"""
return self.get_all_entities(return_models=True, is_active=is_active)
|
[
"def",
"all_entities",
"(",
"self",
",",
"is_active",
"=",
"True",
")",
":",
"return",
"self",
".",
"get_all_entities",
"(",
"return_models",
"=",
"True",
",",
"is_active",
"=",
"is_active",
")"
] |
Return all the entities in the group.
Because groups can contain both individual entities, as well
as whole groups of entities, this method acts as a convenient
way to get a queryset of all the entities in the group.
|
[
"Return",
"all",
"the",
"entities",
"in",
"the",
"group",
"."
] |
ebc61f34313c52f4ef5819eb1da25b2ad837e80c
|
https://github.com/ambitioninc/django-entity/blob/ebc61f34313c52f4ef5819eb1da25b2ad837e80c/entity/models.py#L364-L372
|
train
|
ambitioninc/django-entity
|
entity/models.py
|
EntityGroup.get_all_entities
|
def get_all_entities(self, membership_cache=None, entities_by_kind=None, return_models=False, is_active=True):
"""
Returns a list of all entity ids in this group or optionally returns a queryset for all entity models.
In order to reduce queries for multiple group lookups, it is expected that the membership_cache and
entities_by_kind are built outside of this method and passed in as arguments.
:param membership_cache: A group cache dict generated from `EntityGroup.objects.get_membership_cache()`
:type membership_cache: dict
:param entities_by_kind: An entities by kind dict generated from the `get_entities_by_kind` function
:type entities_by_kind: dict
:param return_models: If True, returns an Entity queryset, if False, returns a set of entity ids
:type return_models: bool
:param is_active: Flag to control entities being returned. Defaults to True for active entities only
:type is_active: bool
"""
# If cache args were not passed, generate the cache
if membership_cache is None:
membership_cache = EntityGroup.objects.get_membership_cache([self.id], is_active=is_active)
if entities_by_kind is None:
entities_by_kind = entities_by_kind or get_entities_by_kind(membership_cache=membership_cache)
# Build set of all entity ids for this group
entity_ids = set()
# This group does have entities
if membership_cache.get(self.id):
# Loop over each membership in this group
for entity_id, entity_kind_id in membership_cache[self.id]:
if entity_id:
if entity_kind_id:
# All sub entities of this kind under this entity
entity_ids.update(entities_by_kind[entity_kind_id][entity_id])
else:
# Individual entity
entity_ids.add(entity_id)
else:
# All entities of this kind
entity_ids.update(entities_by_kind[entity_kind_id]['all'])
# Check if a queryset needs to be returned
if return_models:
return Entity.objects.filter(id__in=entity_ids)
return entity_ids
|
python
|
def get_all_entities(self, membership_cache=None, entities_by_kind=None, return_models=False, is_active=True):
"""
Returns a list of all entity ids in this group or optionally returns a queryset for all entity models.
In order to reduce queries for multiple group lookups, it is expected that the membership_cache and
entities_by_kind are built outside of this method and passed in as arguments.
:param membership_cache: A group cache dict generated from `EntityGroup.objects.get_membership_cache()`
:type membership_cache: dict
:param entities_by_kind: An entities by kind dict generated from the `get_entities_by_kind` function
:type entities_by_kind: dict
:param return_models: If True, returns an Entity queryset, if False, returns a set of entity ids
:type return_models: bool
:param is_active: Flag to control entities being returned. Defaults to True for active entities only
:type is_active: bool
"""
# If cache args were not passed, generate the cache
if membership_cache is None:
membership_cache = EntityGroup.objects.get_membership_cache([self.id], is_active=is_active)
if entities_by_kind is None:
entities_by_kind = entities_by_kind or get_entities_by_kind(membership_cache=membership_cache)
# Build set of all entity ids for this group
entity_ids = set()
# This group does have entities
if membership_cache.get(self.id):
# Loop over each membership in this group
for entity_id, entity_kind_id in membership_cache[self.id]:
if entity_id:
if entity_kind_id:
# All sub entities of this kind under this entity
entity_ids.update(entities_by_kind[entity_kind_id][entity_id])
else:
# Individual entity
entity_ids.add(entity_id)
else:
# All entities of this kind
entity_ids.update(entities_by_kind[entity_kind_id]['all'])
# Check if a queryset needs to be returned
if return_models:
return Entity.objects.filter(id__in=entity_ids)
return entity_ids
|
[
"def",
"get_all_entities",
"(",
"self",
",",
"membership_cache",
"=",
"None",
",",
"entities_by_kind",
"=",
"None",
",",
"return_models",
"=",
"False",
",",
"is_active",
"=",
"True",
")",
":",
"# If cache args were not passed, generate the cache",
"if",
"membership_cache",
"is",
"None",
":",
"membership_cache",
"=",
"EntityGroup",
".",
"objects",
".",
"get_membership_cache",
"(",
"[",
"self",
".",
"id",
"]",
",",
"is_active",
"=",
"is_active",
")",
"if",
"entities_by_kind",
"is",
"None",
":",
"entities_by_kind",
"=",
"entities_by_kind",
"or",
"get_entities_by_kind",
"(",
"membership_cache",
"=",
"membership_cache",
")",
"# Build set of all entity ids for this group",
"entity_ids",
"=",
"set",
"(",
")",
"# This group does have entities",
"if",
"membership_cache",
".",
"get",
"(",
"self",
".",
"id",
")",
":",
"# Loop over each membership in this group",
"for",
"entity_id",
",",
"entity_kind_id",
"in",
"membership_cache",
"[",
"self",
".",
"id",
"]",
":",
"if",
"entity_id",
":",
"if",
"entity_kind_id",
":",
"# All sub entities of this kind under this entity",
"entity_ids",
".",
"update",
"(",
"entities_by_kind",
"[",
"entity_kind_id",
"]",
"[",
"entity_id",
"]",
")",
"else",
":",
"# Individual entity",
"entity_ids",
".",
"add",
"(",
"entity_id",
")",
"else",
":",
"# All entities of this kind",
"entity_ids",
".",
"update",
"(",
"entities_by_kind",
"[",
"entity_kind_id",
"]",
"[",
"'all'",
"]",
")",
"# Check if a queryset needs to be returned",
"if",
"return_models",
":",
"return",
"Entity",
".",
"objects",
".",
"filter",
"(",
"id__in",
"=",
"entity_ids",
")",
"return",
"entity_ids"
] |
Returns a list of all entity ids in this group or optionally returns a queryset for all entity models.
In order to reduce queries for multiple group lookups, it is expected that the membership_cache and
entities_by_kind are built outside of this method and passed in as arguments.
:param membership_cache: A group cache dict generated from `EntityGroup.objects.get_membership_cache()`
:type membership_cache: dict
:param entities_by_kind: An entities by kind dict generated from the `get_entities_by_kind` function
:type entities_by_kind: dict
:param return_models: If True, returns an Entity queryset, if False, returns a set of entity ids
:type return_models: bool
:param is_active: Flag to control entities being returned. Defaults to True for active entities only
:type is_active: bool
|
[
"Returns",
"a",
"list",
"of",
"all",
"entity",
"ids",
"in",
"this",
"group",
"or",
"optionally",
"returns",
"a",
"queryset",
"for",
"all",
"entity",
"models",
".",
"In",
"order",
"to",
"reduce",
"queries",
"for",
"multiple",
"group",
"lookups",
"it",
"is",
"expected",
"that",
"the",
"membership_cache",
"and",
"entities_by_kind",
"are",
"built",
"outside",
"of",
"this",
"method",
"and",
"passed",
"in",
"as",
"arguments",
".",
":",
"param",
"membership_cache",
":",
"A",
"group",
"cache",
"dict",
"generated",
"from",
"EntityGroup",
".",
"objects",
".",
"get_membership_cache",
"()",
":",
"type",
"membership_cache",
":",
"dict",
":",
"param",
"entities_by_kind",
":",
"An",
"entities",
"by",
"kind",
"dict",
"generated",
"from",
"the",
"get_entities_by_kind",
"function",
":",
"type",
"entities_by_kind",
":",
"dict",
":",
"param",
"return_models",
":",
"If",
"True",
"returns",
"an",
"Entity",
"queryset",
"if",
"False",
"returns",
"a",
"set",
"of",
"entity",
"ids",
":",
"type",
"return_models",
":",
"bool",
":",
"param",
"is_active",
":",
"Flag",
"to",
"control",
"entities",
"being",
"returned",
".",
"Defaults",
"to",
"True",
"for",
"active",
"entities",
"only",
":",
"type",
"is_active",
":",
"bool"
] |
ebc61f34313c52f4ef5819eb1da25b2ad837e80c
|
https://github.com/ambitioninc/django-entity/blob/ebc61f34313c52f4ef5819eb1da25b2ad837e80c/entity/models.py#L374-L418
|
train
|
ambitioninc/django-entity
|
entity/models.py
|
EntityGroup.add_entity
|
def add_entity(self, entity, sub_entity_kind=None):
"""
Add an entity, or sub-entity group to this EntityGroup.
:type entity: Entity
:param entity: The entity to add.
:type sub_entity_kind: Optional EntityKind
:param sub_entity_kind: If a sub_entity_kind is given, all
sub_entities of the entity will be added to this
EntityGroup.
"""
membership = EntityGroupMembership.objects.create(
entity_group=self,
entity=entity,
sub_entity_kind=sub_entity_kind,
)
return membership
|
python
|
def add_entity(self, entity, sub_entity_kind=None):
"""
Add an entity, or sub-entity group to this EntityGroup.
:type entity: Entity
:param entity: The entity to add.
:type sub_entity_kind: Optional EntityKind
:param sub_entity_kind: If a sub_entity_kind is given, all
sub_entities of the entity will be added to this
EntityGroup.
"""
membership = EntityGroupMembership.objects.create(
entity_group=self,
entity=entity,
sub_entity_kind=sub_entity_kind,
)
return membership
|
[
"def",
"add_entity",
"(",
"self",
",",
"entity",
",",
"sub_entity_kind",
"=",
"None",
")",
":",
"membership",
"=",
"EntityGroupMembership",
".",
"objects",
".",
"create",
"(",
"entity_group",
"=",
"self",
",",
"entity",
"=",
"entity",
",",
"sub_entity_kind",
"=",
"sub_entity_kind",
",",
")",
"return",
"membership"
] |
Add an entity, or sub-entity group to this EntityGroup.
:type entity: Entity
:param entity: The entity to add.
:type sub_entity_kind: Optional EntityKind
:param sub_entity_kind: If a sub_entity_kind is given, all
sub_entities of the entity will be added to this
EntityGroup.
|
[
"Add",
"an",
"entity",
"or",
"sub",
"-",
"entity",
"group",
"to",
"this",
"EntityGroup",
"."
] |
ebc61f34313c52f4ef5819eb1da25b2ad837e80c
|
https://github.com/ambitioninc/django-entity/blob/ebc61f34313c52f4ef5819eb1da25b2ad837e80c/entity/models.py#L420-L437
|
train
|
ambitioninc/django-entity
|
entity/models.py
|
EntityGroup.bulk_add_entities
|
def bulk_add_entities(self, entities_and_kinds):
"""
Add many entities and sub-entity groups to this EntityGroup.
:type entities_and_kinds: List of (Entity, EntityKind) pairs.
:param entities_and_kinds: A list of entity, entity-kind pairs
to add to the group. In the pairs the entity-kind can be
``None``, to add a single entity, or some entity kind to
add all sub-entities of that kind.
"""
memberships = [EntityGroupMembership(
entity_group=self,
entity=entity,
sub_entity_kind=sub_entity_kind,
) for entity, sub_entity_kind in entities_and_kinds]
created = EntityGroupMembership.objects.bulk_create(memberships)
return created
|
python
|
def bulk_add_entities(self, entities_and_kinds):
"""
Add many entities and sub-entity groups to this EntityGroup.
:type entities_and_kinds: List of (Entity, EntityKind) pairs.
:param entities_and_kinds: A list of entity, entity-kind pairs
to add to the group. In the pairs the entity-kind can be
``None``, to add a single entity, or some entity kind to
add all sub-entities of that kind.
"""
memberships = [EntityGroupMembership(
entity_group=self,
entity=entity,
sub_entity_kind=sub_entity_kind,
) for entity, sub_entity_kind in entities_and_kinds]
created = EntityGroupMembership.objects.bulk_create(memberships)
return created
|
[
"def",
"bulk_add_entities",
"(",
"self",
",",
"entities_and_kinds",
")",
":",
"memberships",
"=",
"[",
"EntityGroupMembership",
"(",
"entity_group",
"=",
"self",
",",
"entity",
"=",
"entity",
",",
"sub_entity_kind",
"=",
"sub_entity_kind",
",",
")",
"for",
"entity",
",",
"sub_entity_kind",
"in",
"entities_and_kinds",
"]",
"created",
"=",
"EntityGroupMembership",
".",
"objects",
".",
"bulk_create",
"(",
"memberships",
")",
"return",
"created"
] |
Add many entities and sub-entity groups to this EntityGroup.
:type entities_and_kinds: List of (Entity, EntityKind) pairs.
:param entities_and_kinds: A list of entity, entity-kind pairs
to add to the group. In the pairs the entity-kind can be
``None``, to add a single entity, or some entity kind to
add all sub-entities of that kind.
|
[
"Add",
"many",
"entities",
"and",
"sub",
"-",
"entity",
"groups",
"to",
"this",
"EntityGroup",
"."
] |
ebc61f34313c52f4ef5819eb1da25b2ad837e80c
|
https://github.com/ambitioninc/django-entity/blob/ebc61f34313c52f4ef5819eb1da25b2ad837e80c/entity/models.py#L439-L455
|
train
|
ambitioninc/django-entity
|
entity/models.py
|
EntityGroup.remove_entity
|
def remove_entity(self, entity, sub_entity_kind=None):
"""
Remove an entity, or sub-entity group to this EntityGroup.
:type entity: Entity
:param entity: The entity to remove.
:type sub_entity_kind: Optional EntityKind
:param sub_entity_kind: If a sub_entity_kind is given, all
sub_entities of the entity will be removed from this
EntityGroup.
"""
EntityGroupMembership.objects.get(
entity_group=self,
entity=entity,
sub_entity_kind=sub_entity_kind,
).delete()
|
python
|
def remove_entity(self, entity, sub_entity_kind=None):
"""
Remove an entity, or sub-entity group to this EntityGroup.
:type entity: Entity
:param entity: The entity to remove.
:type sub_entity_kind: Optional EntityKind
:param sub_entity_kind: If a sub_entity_kind is given, all
sub_entities of the entity will be removed from this
EntityGroup.
"""
EntityGroupMembership.objects.get(
entity_group=self,
entity=entity,
sub_entity_kind=sub_entity_kind,
).delete()
|
[
"def",
"remove_entity",
"(",
"self",
",",
"entity",
",",
"sub_entity_kind",
"=",
"None",
")",
":",
"EntityGroupMembership",
".",
"objects",
".",
"get",
"(",
"entity_group",
"=",
"self",
",",
"entity",
"=",
"entity",
",",
"sub_entity_kind",
"=",
"sub_entity_kind",
",",
")",
".",
"delete",
"(",
")"
] |
Remove an entity, or sub-entity group to this EntityGroup.
:type entity: Entity
:param entity: The entity to remove.
:type sub_entity_kind: Optional EntityKind
:param sub_entity_kind: If a sub_entity_kind is given, all
sub_entities of the entity will be removed from this
EntityGroup.
|
[
"Remove",
"an",
"entity",
"or",
"sub",
"-",
"entity",
"group",
"to",
"this",
"EntityGroup",
"."
] |
ebc61f34313c52f4ef5819eb1da25b2ad837e80c
|
https://github.com/ambitioninc/django-entity/blob/ebc61f34313c52f4ef5819eb1da25b2ad837e80c/entity/models.py#L457-L473
|
train
|
ambitioninc/django-entity
|
entity/models.py
|
EntityGroup.bulk_remove_entities
|
def bulk_remove_entities(self, entities_and_kinds):
"""
Remove many entities and sub-entity groups to this EntityGroup.
:type entities_and_kinds: List of (Entity, EntityKind) pairs.
:param entities_and_kinds: A list of entity, entity-kind pairs
to remove from the group. In the pairs, the entity-kind
can be ``None``, to add a single entity, or some entity
kind to add all sub-entities of that kind.
"""
criteria = [
Q(entity=entity, sub_entity_kind=entity_kind)
for entity, entity_kind in entities_and_kinds
]
criteria = reduce(lambda q1, q2: q1 | q2, criteria, Q())
EntityGroupMembership.objects.filter(
criteria, entity_group=self).delete()
|
python
|
def bulk_remove_entities(self, entities_and_kinds):
"""
Remove many entities and sub-entity groups to this EntityGroup.
:type entities_and_kinds: List of (Entity, EntityKind) pairs.
:param entities_and_kinds: A list of entity, entity-kind pairs
to remove from the group. In the pairs, the entity-kind
can be ``None``, to add a single entity, or some entity
kind to add all sub-entities of that kind.
"""
criteria = [
Q(entity=entity, sub_entity_kind=entity_kind)
for entity, entity_kind in entities_and_kinds
]
criteria = reduce(lambda q1, q2: q1 | q2, criteria, Q())
EntityGroupMembership.objects.filter(
criteria, entity_group=self).delete()
|
[
"def",
"bulk_remove_entities",
"(",
"self",
",",
"entities_and_kinds",
")",
":",
"criteria",
"=",
"[",
"Q",
"(",
"entity",
"=",
"entity",
",",
"sub_entity_kind",
"=",
"entity_kind",
")",
"for",
"entity",
",",
"entity_kind",
"in",
"entities_and_kinds",
"]",
"criteria",
"=",
"reduce",
"(",
"lambda",
"q1",
",",
"q2",
":",
"q1",
"|",
"q2",
",",
"criteria",
",",
"Q",
"(",
")",
")",
"EntityGroupMembership",
".",
"objects",
".",
"filter",
"(",
"criteria",
",",
"entity_group",
"=",
"self",
")",
".",
"delete",
"(",
")"
] |
Remove many entities and sub-entity groups to this EntityGroup.
:type entities_and_kinds: List of (Entity, EntityKind) pairs.
:param entities_and_kinds: A list of entity, entity-kind pairs
to remove from the group. In the pairs, the entity-kind
can be ``None``, to add a single entity, or some entity
kind to add all sub-entities of that kind.
|
[
"Remove",
"many",
"entities",
"and",
"sub",
"-",
"entity",
"groups",
"to",
"this",
"EntityGroup",
"."
] |
ebc61f34313c52f4ef5819eb1da25b2ad837e80c
|
https://github.com/ambitioninc/django-entity/blob/ebc61f34313c52f4ef5819eb1da25b2ad837e80c/entity/models.py#L475-L491
|
train
|
ambitioninc/django-entity
|
entity/models.py
|
EntityGroup.bulk_overwrite
|
def bulk_overwrite(self, entities_and_kinds):
"""
Update the group to the given entities and sub-entity groups.
After this operation, the only members of this EntityGroup
will be the given entities, and sub-entity groups.
:type entities_and_kinds: List of (Entity, EntityKind) pairs.
:param entities_and_kinds: A list of entity, entity-kind pairs
to set to the EntityGroup. In the pairs the entity-kind
can be ``None``, to add a single entity, or some entity
kind to add all sub-entities of that kind.
"""
EntityGroupMembership.objects.filter(entity_group=self).delete()
return self.bulk_add_entities(entities_and_kinds)
|
python
|
def bulk_overwrite(self, entities_and_kinds):
"""
Update the group to the given entities and sub-entity groups.
After this operation, the only members of this EntityGroup
will be the given entities, and sub-entity groups.
:type entities_and_kinds: List of (Entity, EntityKind) pairs.
:param entities_and_kinds: A list of entity, entity-kind pairs
to set to the EntityGroup. In the pairs the entity-kind
can be ``None``, to add a single entity, or some entity
kind to add all sub-entities of that kind.
"""
EntityGroupMembership.objects.filter(entity_group=self).delete()
return self.bulk_add_entities(entities_and_kinds)
|
[
"def",
"bulk_overwrite",
"(",
"self",
",",
"entities_and_kinds",
")",
":",
"EntityGroupMembership",
".",
"objects",
".",
"filter",
"(",
"entity_group",
"=",
"self",
")",
".",
"delete",
"(",
")",
"return",
"self",
".",
"bulk_add_entities",
"(",
"entities_and_kinds",
")"
] |
Update the group to the given entities and sub-entity groups.
After this operation, the only members of this EntityGroup
will be the given entities, and sub-entity groups.
:type entities_and_kinds: List of (Entity, EntityKind) pairs.
:param entities_and_kinds: A list of entity, entity-kind pairs
to set to the EntityGroup. In the pairs the entity-kind
can be ``None``, to add a single entity, or some entity
kind to add all sub-entities of that kind.
|
[
"Update",
"the",
"group",
"to",
"the",
"given",
"entities",
"and",
"sub",
"-",
"entity",
"groups",
"."
] |
ebc61f34313c52f4ef5819eb1da25b2ad837e80c
|
https://github.com/ambitioninc/django-entity/blob/ebc61f34313c52f4ef5819eb1da25b2ad837e80c/entity/models.py#L493-L507
|
train
|
philgyford/django-spectator
|
spectator/events/migrations/0007_work_slug_20180102_1137.py
|
generate_slug
|
def generate_slug(value):
"A copy of spectator.core.models.SluggedModelMixin._generate_slug()"
alphabet = 'abcdefghijkmnopqrstuvwxyz23456789'
salt = 'Django Spectator'
if hasattr(settings, 'SPECTATOR_SLUG_ALPHABET'):
alphabet = settings.SPECTATOR_SLUG_ALPHABET
if hasattr(settings, 'SPECTATOR_SLUG_SALT'):
salt = settings.SPECTATOR_SLUG_SALT
hashids = Hashids(alphabet=alphabet, salt=salt, min_length=5)
return hashids.encode(value)
|
python
|
def generate_slug(value):
"A copy of spectator.core.models.SluggedModelMixin._generate_slug()"
alphabet = 'abcdefghijkmnopqrstuvwxyz23456789'
salt = 'Django Spectator'
if hasattr(settings, 'SPECTATOR_SLUG_ALPHABET'):
alphabet = settings.SPECTATOR_SLUG_ALPHABET
if hasattr(settings, 'SPECTATOR_SLUG_SALT'):
salt = settings.SPECTATOR_SLUG_SALT
hashids = Hashids(alphabet=alphabet, salt=salt, min_length=5)
return hashids.encode(value)
|
[
"def",
"generate_slug",
"(",
"value",
")",
":",
"alphabet",
"=",
"'abcdefghijkmnopqrstuvwxyz23456789'",
"salt",
"=",
"'Django Spectator'",
"if",
"hasattr",
"(",
"settings",
",",
"'SPECTATOR_SLUG_ALPHABET'",
")",
":",
"alphabet",
"=",
"settings",
".",
"SPECTATOR_SLUG_ALPHABET",
"if",
"hasattr",
"(",
"settings",
",",
"'SPECTATOR_SLUG_SALT'",
")",
":",
"salt",
"=",
"settings",
".",
"SPECTATOR_SLUG_SALT",
"hashids",
"=",
"Hashids",
"(",
"alphabet",
"=",
"alphabet",
",",
"salt",
"=",
"salt",
",",
"min_length",
"=",
"5",
")",
"return",
"hashids",
".",
"encode",
"(",
"value",
")"
] |
A copy of spectator.core.models.SluggedModelMixin._generate_slug()
|
[
"A",
"copy",
"of",
"spectator",
".",
"core",
".",
"models",
".",
"SluggedModelMixin",
".",
"_generate_slug",
"()"
] |
f3c72004f9caa1fde0f5a3b2f0d2bf285fc01ada
|
https://github.com/philgyford/django-spectator/blob/f3c72004f9caa1fde0f5a3b2f0d2bf285fc01ada/spectator/events/migrations/0007_work_slug_20180102_1137.py#L8-L21
|
train
|
philgyford/django-spectator
|
spectator/events/migrations/0007_work_slug_20180102_1137.py
|
set_slug
|
def set_slug(apps, schema_editor, class_name):
"""
Create a slug for each Work already in the DB.
"""
Cls = apps.get_model('spectator_events', class_name)
for obj in Cls.objects.all():
obj.slug = generate_slug(obj.pk)
obj.save(update_fields=['slug'])
|
python
|
def set_slug(apps, schema_editor, class_name):
"""
Create a slug for each Work already in the DB.
"""
Cls = apps.get_model('spectator_events', class_name)
for obj in Cls.objects.all():
obj.slug = generate_slug(obj.pk)
obj.save(update_fields=['slug'])
|
[
"def",
"set_slug",
"(",
"apps",
",",
"schema_editor",
",",
"class_name",
")",
":",
"Cls",
"=",
"apps",
".",
"get_model",
"(",
"'spectator_events'",
",",
"class_name",
")",
"for",
"obj",
"in",
"Cls",
".",
"objects",
".",
"all",
"(",
")",
":",
"obj",
".",
"slug",
"=",
"generate_slug",
"(",
"obj",
".",
"pk",
")",
"obj",
".",
"save",
"(",
"update_fields",
"=",
"[",
"'slug'",
"]",
")"
] |
Create a slug for each Work already in the DB.
|
[
"Create",
"a",
"slug",
"for",
"each",
"Work",
"already",
"in",
"the",
"DB",
"."
] |
f3c72004f9caa1fde0f5a3b2f0d2bf285fc01ada
|
https://github.com/philgyford/django-spectator/blob/f3c72004f9caa1fde0f5a3b2f0d2bf285fc01ada/spectator/events/migrations/0007_work_slug_20180102_1137.py#L24-L32
|
train
|
philgyford/django-spectator
|
spectator/events/models.py
|
Event.kind_name
|
def kind_name(self):
"e.g. 'Gig' or 'Movie'."
return {k:v for (k,v) in self.KIND_CHOICES}[self.kind]
|
python
|
def kind_name(self):
"e.g. 'Gig' or 'Movie'."
return {k:v for (k,v) in self.KIND_CHOICES}[self.kind]
|
[
"def",
"kind_name",
"(",
"self",
")",
":",
"return",
"{",
"k",
":",
"v",
"for",
"(",
"k",
",",
"v",
")",
"in",
"self",
".",
"KIND_CHOICES",
"}",
"[",
"self",
".",
"kind",
"]"
] |
e.g. 'Gig' or 'Movie'.
|
[
"e",
".",
"g",
".",
"Gig",
"or",
"Movie",
"."
] |
f3c72004f9caa1fde0f5a3b2f0d2bf285fc01ada
|
https://github.com/philgyford/django-spectator/blob/f3c72004f9caa1fde0f5a3b2f0d2bf285fc01ada/spectator/events/models.py#L231-L233
|
train
|
philgyford/django-spectator
|
spectator/events/models.py
|
Event.get_kind_name_plural
|
def get_kind_name_plural(kind):
"e.g. 'Gigs' or 'Movies'."
if kind in ['comedy', 'cinema', 'dance', 'theatre']:
return kind.title()
elif kind == 'museum':
return 'Galleries/Museums'
else:
return '{}s'.format(Event.get_kind_name(kind))
|
python
|
def get_kind_name_plural(kind):
"e.g. 'Gigs' or 'Movies'."
if kind in ['comedy', 'cinema', 'dance', 'theatre']:
return kind.title()
elif kind == 'museum':
return 'Galleries/Museums'
else:
return '{}s'.format(Event.get_kind_name(kind))
|
[
"def",
"get_kind_name_plural",
"(",
"kind",
")",
":",
"if",
"kind",
"in",
"[",
"'comedy'",
",",
"'cinema'",
",",
"'dance'",
",",
"'theatre'",
"]",
":",
"return",
"kind",
".",
"title",
"(",
")",
"elif",
"kind",
"==",
"'museum'",
":",
"return",
"'Galleries/Museums'",
"else",
":",
"return",
"'{}s'",
".",
"format",
"(",
"Event",
".",
"get_kind_name",
"(",
"kind",
")",
")"
] |
e.g. 'Gigs' or 'Movies'.
|
[
"e",
".",
"g",
".",
"Gigs",
"or",
"Movies",
"."
] |
f3c72004f9caa1fde0f5a3b2f0d2bf285fc01ada
|
https://github.com/philgyford/django-spectator/blob/f3c72004f9caa1fde0f5a3b2f0d2bf285fc01ada/spectator/events/models.py#L250-L257
|
train
|
philgyford/django-spectator
|
spectator/events/models.py
|
Event.get_kinds_data
|
def get_kinds_data():
"""
Returns a dict of all the data about the kinds, keyed to the kind
value. e.g:
{
'gig': {
'name': 'Gig',
'slug': 'gigs',
'name_plural': 'Gigs',
},
# etc
}
"""
kinds = {k:{'name':v} for k,v in Event.KIND_CHOICES}
for k,data in kinds.items():
kinds[k]['slug'] = Event.KIND_SLUGS[k]
kinds[k]['name_plural'] = Event.get_kind_name_plural(k)
return kinds
|
python
|
def get_kinds_data():
"""
Returns a dict of all the data about the kinds, keyed to the kind
value. e.g:
{
'gig': {
'name': 'Gig',
'slug': 'gigs',
'name_plural': 'Gigs',
},
# etc
}
"""
kinds = {k:{'name':v} for k,v in Event.KIND_CHOICES}
for k,data in kinds.items():
kinds[k]['slug'] = Event.KIND_SLUGS[k]
kinds[k]['name_plural'] = Event.get_kind_name_plural(k)
return kinds
|
[
"def",
"get_kinds_data",
"(",
")",
":",
"kinds",
"=",
"{",
"k",
":",
"{",
"'name'",
":",
"v",
"}",
"for",
"k",
",",
"v",
"in",
"Event",
".",
"KIND_CHOICES",
"}",
"for",
"k",
",",
"data",
"in",
"kinds",
".",
"items",
"(",
")",
":",
"kinds",
"[",
"k",
"]",
"[",
"'slug'",
"]",
"=",
"Event",
".",
"KIND_SLUGS",
"[",
"k",
"]",
"kinds",
"[",
"k",
"]",
"[",
"'name_plural'",
"]",
"=",
"Event",
".",
"get_kind_name_plural",
"(",
"k",
")",
"return",
"kinds"
] |
Returns a dict of all the data about the kinds, keyed to the kind
value. e.g:
{
'gig': {
'name': 'Gig',
'slug': 'gigs',
'name_plural': 'Gigs',
},
# etc
}
|
[
"Returns",
"a",
"dict",
"of",
"all",
"the",
"data",
"about",
"the",
"kinds",
"keyed",
"to",
"the",
"kind",
"value",
".",
"e",
".",
"g",
":",
"{",
"gig",
":",
"{",
"name",
":",
"Gig",
"slug",
":",
"gigs",
"name_plural",
":",
"Gigs",
"}",
"#",
"etc",
"}"
] |
f3c72004f9caa1fde0f5a3b2f0d2bf285fc01ada
|
https://github.com/philgyford/django-spectator/blob/f3c72004f9caa1fde0f5a3b2f0d2bf285fc01ada/spectator/events/models.py#L277-L294
|
train
|
philgyford/django-spectator
|
spectator/events/models.py
|
Work.get_list_url
|
def get_list_url(self, kind_slug=None):
"""
Get the list URL for this Work.
You can also pass a kind_slug in (e.g. 'movies') and it will use that
instead of the Work's kind_slug. (Why? Useful in views. Or tests of
views, at least.)
"""
if kind_slug is None:
kind_slug = self.KIND_SLUGS[self.kind]
return reverse('spectator:events:work_list',
kwargs={'kind_slug': kind_slug})
|
python
|
def get_list_url(self, kind_slug=None):
"""
Get the list URL for this Work.
You can also pass a kind_slug in (e.g. 'movies') and it will use that
instead of the Work's kind_slug. (Why? Useful in views. Or tests of
views, at least.)
"""
if kind_slug is None:
kind_slug = self.KIND_SLUGS[self.kind]
return reverse('spectator:events:work_list',
kwargs={'kind_slug': kind_slug})
|
[
"def",
"get_list_url",
"(",
"self",
",",
"kind_slug",
"=",
"None",
")",
":",
"if",
"kind_slug",
"is",
"None",
":",
"kind_slug",
"=",
"self",
".",
"KIND_SLUGS",
"[",
"self",
".",
"kind",
"]",
"return",
"reverse",
"(",
"'spectator:events:work_list'",
",",
"kwargs",
"=",
"{",
"'kind_slug'",
":",
"kind_slug",
"}",
")"
] |
Get the list URL for this Work.
You can also pass a kind_slug in (e.g. 'movies') and it will use that
instead of the Work's kind_slug. (Why? Useful in views. Or tests of
views, at least.)
|
[
"Get",
"the",
"list",
"URL",
"for",
"this",
"Work",
".",
"You",
"can",
"also",
"pass",
"a",
"kind_slug",
"in",
"(",
"e",
".",
"g",
".",
"movies",
")",
"and",
"it",
"will",
"use",
"that",
"instead",
"of",
"the",
"Work",
"s",
"kind_slug",
".",
"(",
"Why?",
"Useful",
"in",
"views",
".",
"Or",
"tests",
"of",
"views",
"at",
"least",
".",
")"
] |
f3c72004f9caa1fde0f5a3b2f0d2bf285fc01ada
|
https://github.com/philgyford/django-spectator/blob/f3c72004f9caa1fde0f5a3b2f0d2bf285fc01ada/spectator/events/models.py#L379-L389
|
train
|
frictionlessdata/tableschema-pandas-py
|
tableschema_pandas/mapper.py
|
Mapper.convert_descriptor_and_rows
|
def convert_descriptor_and_rows(self, descriptor, rows):
"""Convert descriptor and rows to Pandas
"""
# Prepare
primary_key = None
schema = tableschema.Schema(descriptor)
if len(schema.primary_key) == 1:
primary_key = schema.primary_key[0]
elif len(schema.primary_key) > 1:
message = 'Multi-column primary keys are not supported'
raise tableschema.exceptions.StorageError(message)
# Get data/index
data_rows = []
index_rows = []
jtstypes_map = {}
for row in rows:
values = []
index = None
for field, value in zip(schema.fields, row):
try:
if isinstance(value, float) and np.isnan(value):
value = None
if value and field.type == 'integer':
value = int(value)
value = field.cast_value(value)
except tableschema.exceptions.CastError:
value = json.loads(value)
# http://pandas.pydata.org/pandas-docs/stable/gotchas.html#support-for-integer-na
if value is None and field.type in ('number', 'integer'):
jtstypes_map[field.name] = 'number'
value = np.NaN
if field.name == primary_key:
index = value
else:
values.append(value)
data_rows.append(tuple(values))
index_rows.append(index)
# Get dtypes
dtypes = []
for field in schema.fields:
if field.name != primary_key:
field_name = field.name
if six.PY2:
field_name = field.name.encode('utf-8')
dtype = self.convert_type(jtstypes_map.get(field.name, field.type))
dtypes.append((field_name, dtype))
# Create dataframe
index = None
columns = schema.headers
array = np.array(data_rows, dtype=dtypes)
if primary_key:
index_field = schema.get_field(primary_key)
index_dtype = self.convert_type(index_field.type)
index_class = pd.Index
if index_field.type in ['datetime', 'date']:
index_class = pd.DatetimeIndex
index = index_class(index_rows, name=primary_key, dtype=index_dtype)
columns = filter(lambda column: column != primary_key, schema.headers)
dataframe = pd.DataFrame(array, index=index, columns=columns)
return dataframe
|
python
|
def convert_descriptor_and_rows(self, descriptor, rows):
"""Convert descriptor and rows to Pandas
"""
# Prepare
primary_key = None
schema = tableschema.Schema(descriptor)
if len(schema.primary_key) == 1:
primary_key = schema.primary_key[0]
elif len(schema.primary_key) > 1:
message = 'Multi-column primary keys are not supported'
raise tableschema.exceptions.StorageError(message)
# Get data/index
data_rows = []
index_rows = []
jtstypes_map = {}
for row in rows:
values = []
index = None
for field, value in zip(schema.fields, row):
try:
if isinstance(value, float) and np.isnan(value):
value = None
if value and field.type == 'integer':
value = int(value)
value = field.cast_value(value)
except tableschema.exceptions.CastError:
value = json.loads(value)
# http://pandas.pydata.org/pandas-docs/stable/gotchas.html#support-for-integer-na
if value is None and field.type in ('number', 'integer'):
jtstypes_map[field.name] = 'number'
value = np.NaN
if field.name == primary_key:
index = value
else:
values.append(value)
data_rows.append(tuple(values))
index_rows.append(index)
# Get dtypes
dtypes = []
for field in schema.fields:
if field.name != primary_key:
field_name = field.name
if six.PY2:
field_name = field.name.encode('utf-8')
dtype = self.convert_type(jtstypes_map.get(field.name, field.type))
dtypes.append((field_name, dtype))
# Create dataframe
index = None
columns = schema.headers
array = np.array(data_rows, dtype=dtypes)
if primary_key:
index_field = schema.get_field(primary_key)
index_dtype = self.convert_type(index_field.type)
index_class = pd.Index
if index_field.type in ['datetime', 'date']:
index_class = pd.DatetimeIndex
index = index_class(index_rows, name=primary_key, dtype=index_dtype)
columns = filter(lambda column: column != primary_key, schema.headers)
dataframe = pd.DataFrame(array, index=index, columns=columns)
return dataframe
|
[
"def",
"convert_descriptor_and_rows",
"(",
"self",
",",
"descriptor",
",",
"rows",
")",
":",
"# Prepare",
"primary_key",
"=",
"None",
"schema",
"=",
"tableschema",
".",
"Schema",
"(",
"descriptor",
")",
"if",
"len",
"(",
"schema",
".",
"primary_key",
")",
"==",
"1",
":",
"primary_key",
"=",
"schema",
".",
"primary_key",
"[",
"0",
"]",
"elif",
"len",
"(",
"schema",
".",
"primary_key",
")",
">",
"1",
":",
"message",
"=",
"'Multi-column primary keys are not supported'",
"raise",
"tableschema",
".",
"exceptions",
".",
"StorageError",
"(",
"message",
")",
"# Get data/index",
"data_rows",
"=",
"[",
"]",
"index_rows",
"=",
"[",
"]",
"jtstypes_map",
"=",
"{",
"}",
"for",
"row",
"in",
"rows",
":",
"values",
"=",
"[",
"]",
"index",
"=",
"None",
"for",
"field",
",",
"value",
"in",
"zip",
"(",
"schema",
".",
"fields",
",",
"row",
")",
":",
"try",
":",
"if",
"isinstance",
"(",
"value",
",",
"float",
")",
"and",
"np",
".",
"isnan",
"(",
"value",
")",
":",
"value",
"=",
"None",
"if",
"value",
"and",
"field",
".",
"type",
"==",
"'integer'",
":",
"value",
"=",
"int",
"(",
"value",
")",
"value",
"=",
"field",
".",
"cast_value",
"(",
"value",
")",
"except",
"tableschema",
".",
"exceptions",
".",
"CastError",
":",
"value",
"=",
"json",
".",
"loads",
"(",
"value",
")",
"# http://pandas.pydata.org/pandas-docs/stable/gotchas.html#support-for-integer-na",
"if",
"value",
"is",
"None",
"and",
"field",
".",
"type",
"in",
"(",
"'number'",
",",
"'integer'",
")",
":",
"jtstypes_map",
"[",
"field",
".",
"name",
"]",
"=",
"'number'",
"value",
"=",
"np",
".",
"NaN",
"if",
"field",
".",
"name",
"==",
"primary_key",
":",
"index",
"=",
"value",
"else",
":",
"values",
".",
"append",
"(",
"value",
")",
"data_rows",
".",
"append",
"(",
"tuple",
"(",
"values",
")",
")",
"index_rows",
".",
"append",
"(",
"index",
")",
"# Get dtypes",
"dtypes",
"=",
"[",
"]",
"for",
"field",
"in",
"schema",
".",
"fields",
":",
"if",
"field",
".",
"name",
"!=",
"primary_key",
":",
"field_name",
"=",
"field",
".",
"name",
"if",
"six",
".",
"PY2",
":",
"field_name",
"=",
"field",
".",
"name",
".",
"encode",
"(",
"'utf-8'",
")",
"dtype",
"=",
"self",
".",
"convert_type",
"(",
"jtstypes_map",
".",
"get",
"(",
"field",
".",
"name",
",",
"field",
".",
"type",
")",
")",
"dtypes",
".",
"append",
"(",
"(",
"field_name",
",",
"dtype",
")",
")",
"# Create dataframe",
"index",
"=",
"None",
"columns",
"=",
"schema",
".",
"headers",
"array",
"=",
"np",
".",
"array",
"(",
"data_rows",
",",
"dtype",
"=",
"dtypes",
")",
"if",
"primary_key",
":",
"index_field",
"=",
"schema",
".",
"get_field",
"(",
"primary_key",
")",
"index_dtype",
"=",
"self",
".",
"convert_type",
"(",
"index_field",
".",
"type",
")",
"index_class",
"=",
"pd",
".",
"Index",
"if",
"index_field",
".",
"type",
"in",
"[",
"'datetime'",
",",
"'date'",
"]",
":",
"index_class",
"=",
"pd",
".",
"DatetimeIndex",
"index",
"=",
"index_class",
"(",
"index_rows",
",",
"name",
"=",
"primary_key",
",",
"dtype",
"=",
"index_dtype",
")",
"columns",
"=",
"filter",
"(",
"lambda",
"column",
":",
"column",
"!=",
"primary_key",
",",
"schema",
".",
"headers",
")",
"dataframe",
"=",
"pd",
".",
"DataFrame",
"(",
"array",
",",
"index",
"=",
"index",
",",
"columns",
"=",
"columns",
")",
"return",
"dataframe"
] |
Convert descriptor and rows to Pandas
|
[
"Convert",
"descriptor",
"and",
"rows",
"to",
"Pandas"
] |
ef941dbc12f5d346e9612f8fec1b4b356b8493ca
|
https://github.com/frictionlessdata/tableschema-pandas-py/blob/ef941dbc12f5d346e9612f8fec1b4b356b8493ca/tableschema_pandas/mapper.py#L23-L87
|
train
|
frictionlessdata/tableschema-pandas-py
|
tableschema_pandas/mapper.py
|
Mapper.convert_type
|
def convert_type(self, type):
"""Convert type to Pandas
"""
# Mapping
mapping = {
'any': np.dtype('O'),
'array': np.dtype(list),
'boolean': np.dtype(bool),
'date': np.dtype('O'),
'datetime': np.dtype('datetime64[ns]'),
'duration': np.dtype('O'),
'geojson': np.dtype('O'),
'geopoint': np.dtype('O'),
'integer': np.dtype(int),
'number': np.dtype(float),
'object': np.dtype(dict),
'string': np.dtype('O'),
'time': np.dtype('O'),
'year': np.dtype(int),
'yearmonth': np.dtype('O'),
}
# Get type
if type not in mapping:
message = 'Type "%s" is not supported' % type
raise tableschema.exceptions.StorageError(message)
return mapping[type]
|
python
|
def convert_type(self, type):
"""Convert type to Pandas
"""
# Mapping
mapping = {
'any': np.dtype('O'),
'array': np.dtype(list),
'boolean': np.dtype(bool),
'date': np.dtype('O'),
'datetime': np.dtype('datetime64[ns]'),
'duration': np.dtype('O'),
'geojson': np.dtype('O'),
'geopoint': np.dtype('O'),
'integer': np.dtype(int),
'number': np.dtype(float),
'object': np.dtype(dict),
'string': np.dtype('O'),
'time': np.dtype('O'),
'year': np.dtype(int),
'yearmonth': np.dtype('O'),
}
# Get type
if type not in mapping:
message = 'Type "%s" is not supported' % type
raise tableschema.exceptions.StorageError(message)
return mapping[type]
|
[
"def",
"convert_type",
"(",
"self",
",",
"type",
")",
":",
"# Mapping",
"mapping",
"=",
"{",
"'any'",
":",
"np",
".",
"dtype",
"(",
"'O'",
")",
",",
"'array'",
":",
"np",
".",
"dtype",
"(",
"list",
")",
",",
"'boolean'",
":",
"np",
".",
"dtype",
"(",
"bool",
")",
",",
"'date'",
":",
"np",
".",
"dtype",
"(",
"'O'",
")",
",",
"'datetime'",
":",
"np",
".",
"dtype",
"(",
"'datetime64[ns]'",
")",
",",
"'duration'",
":",
"np",
".",
"dtype",
"(",
"'O'",
")",
",",
"'geojson'",
":",
"np",
".",
"dtype",
"(",
"'O'",
")",
",",
"'geopoint'",
":",
"np",
".",
"dtype",
"(",
"'O'",
")",
",",
"'integer'",
":",
"np",
".",
"dtype",
"(",
"int",
")",
",",
"'number'",
":",
"np",
".",
"dtype",
"(",
"float",
")",
",",
"'object'",
":",
"np",
".",
"dtype",
"(",
"dict",
")",
",",
"'string'",
":",
"np",
".",
"dtype",
"(",
"'O'",
")",
",",
"'time'",
":",
"np",
".",
"dtype",
"(",
"'O'",
")",
",",
"'year'",
":",
"np",
".",
"dtype",
"(",
"int",
")",
",",
"'yearmonth'",
":",
"np",
".",
"dtype",
"(",
"'O'",
")",
",",
"}",
"# Get type",
"if",
"type",
"not",
"in",
"mapping",
":",
"message",
"=",
"'Type \"%s\" is not supported'",
"%",
"type",
"raise",
"tableschema",
".",
"exceptions",
".",
"StorageError",
"(",
"message",
")",
"return",
"mapping",
"[",
"type",
"]"
] |
Convert type to Pandas
|
[
"Convert",
"type",
"to",
"Pandas"
] |
ef941dbc12f5d346e9612f8fec1b4b356b8493ca
|
https://github.com/frictionlessdata/tableschema-pandas-py/blob/ef941dbc12f5d346e9612f8fec1b4b356b8493ca/tableschema_pandas/mapper.py#L89-L117
|
train
|
frictionlessdata/tableschema-pandas-py
|
tableschema_pandas/mapper.py
|
Mapper.restore_descriptor
|
def restore_descriptor(self, dataframe):
"""Restore descriptor from Pandas
"""
# Prepare
fields = []
primary_key = None
# Primary key
if dataframe.index.name:
field_type = self.restore_type(dataframe.index.dtype)
field = {
'name': dataframe.index.name,
'type': field_type,
'constraints': {'required': True},
}
fields.append(field)
primary_key = dataframe.index.name
# Fields
for column, dtype in dataframe.dtypes.iteritems():
sample = dataframe[column].iloc[0] if len(dataframe) else None
field_type = self.restore_type(dtype, sample=sample)
field = {'name': column, 'type': field_type}
# TODO: provide better required indication
# if dataframe[column].isnull().sum() == 0:
# field['constraints'] = {'required': True}
fields.append(field)
# Descriptor
descriptor = {}
descriptor['fields'] = fields
if primary_key:
descriptor['primaryKey'] = primary_key
return descriptor
|
python
|
def restore_descriptor(self, dataframe):
"""Restore descriptor from Pandas
"""
# Prepare
fields = []
primary_key = None
# Primary key
if dataframe.index.name:
field_type = self.restore_type(dataframe.index.dtype)
field = {
'name': dataframe.index.name,
'type': field_type,
'constraints': {'required': True},
}
fields.append(field)
primary_key = dataframe.index.name
# Fields
for column, dtype in dataframe.dtypes.iteritems():
sample = dataframe[column].iloc[0] if len(dataframe) else None
field_type = self.restore_type(dtype, sample=sample)
field = {'name': column, 'type': field_type}
# TODO: provide better required indication
# if dataframe[column].isnull().sum() == 0:
# field['constraints'] = {'required': True}
fields.append(field)
# Descriptor
descriptor = {}
descriptor['fields'] = fields
if primary_key:
descriptor['primaryKey'] = primary_key
return descriptor
|
[
"def",
"restore_descriptor",
"(",
"self",
",",
"dataframe",
")",
":",
"# Prepare",
"fields",
"=",
"[",
"]",
"primary_key",
"=",
"None",
"# Primary key",
"if",
"dataframe",
".",
"index",
".",
"name",
":",
"field_type",
"=",
"self",
".",
"restore_type",
"(",
"dataframe",
".",
"index",
".",
"dtype",
")",
"field",
"=",
"{",
"'name'",
":",
"dataframe",
".",
"index",
".",
"name",
",",
"'type'",
":",
"field_type",
",",
"'constraints'",
":",
"{",
"'required'",
":",
"True",
"}",
",",
"}",
"fields",
".",
"append",
"(",
"field",
")",
"primary_key",
"=",
"dataframe",
".",
"index",
".",
"name",
"# Fields",
"for",
"column",
",",
"dtype",
"in",
"dataframe",
".",
"dtypes",
".",
"iteritems",
"(",
")",
":",
"sample",
"=",
"dataframe",
"[",
"column",
"]",
".",
"iloc",
"[",
"0",
"]",
"if",
"len",
"(",
"dataframe",
")",
"else",
"None",
"field_type",
"=",
"self",
".",
"restore_type",
"(",
"dtype",
",",
"sample",
"=",
"sample",
")",
"field",
"=",
"{",
"'name'",
":",
"column",
",",
"'type'",
":",
"field_type",
"}",
"# TODO: provide better required indication",
"# if dataframe[column].isnull().sum() == 0:",
"# field['constraints'] = {'required': True}",
"fields",
".",
"append",
"(",
"field",
")",
"# Descriptor",
"descriptor",
"=",
"{",
"}",
"descriptor",
"[",
"'fields'",
"]",
"=",
"fields",
"if",
"primary_key",
":",
"descriptor",
"[",
"'primaryKey'",
"]",
"=",
"primary_key",
"return",
"descriptor"
] |
Restore descriptor from Pandas
|
[
"Restore",
"descriptor",
"from",
"Pandas"
] |
ef941dbc12f5d346e9612f8fec1b4b356b8493ca
|
https://github.com/frictionlessdata/tableschema-pandas-py/blob/ef941dbc12f5d346e9612f8fec1b4b356b8493ca/tableschema_pandas/mapper.py#L119-L154
|
train
|
frictionlessdata/tableschema-pandas-py
|
tableschema_pandas/mapper.py
|
Mapper.restore_row
|
def restore_row(self, row, schema, pk):
"""Restore row from Pandas
"""
result = []
for field in schema.fields:
if schema.primary_key and schema.primary_key[0] == field.name:
if field.type == 'number' and np.isnan(pk):
pk = None
if pk and field.type == 'integer':
pk = int(pk)
result.append(field.cast_value(pk))
else:
value = row[field.name]
if field.type == 'number' and np.isnan(value):
value = None
if value and field.type == 'integer':
value = int(value)
elif field.type == 'datetime':
value = value.to_pydatetime()
result.append(field.cast_value(value))
return result
|
python
|
def restore_row(self, row, schema, pk):
"""Restore row from Pandas
"""
result = []
for field in schema.fields:
if schema.primary_key and schema.primary_key[0] == field.name:
if field.type == 'number' and np.isnan(pk):
pk = None
if pk and field.type == 'integer':
pk = int(pk)
result.append(field.cast_value(pk))
else:
value = row[field.name]
if field.type == 'number' and np.isnan(value):
value = None
if value and field.type == 'integer':
value = int(value)
elif field.type == 'datetime':
value = value.to_pydatetime()
result.append(field.cast_value(value))
return result
|
[
"def",
"restore_row",
"(",
"self",
",",
"row",
",",
"schema",
",",
"pk",
")",
":",
"result",
"=",
"[",
"]",
"for",
"field",
"in",
"schema",
".",
"fields",
":",
"if",
"schema",
".",
"primary_key",
"and",
"schema",
".",
"primary_key",
"[",
"0",
"]",
"==",
"field",
".",
"name",
":",
"if",
"field",
".",
"type",
"==",
"'number'",
"and",
"np",
".",
"isnan",
"(",
"pk",
")",
":",
"pk",
"=",
"None",
"if",
"pk",
"and",
"field",
".",
"type",
"==",
"'integer'",
":",
"pk",
"=",
"int",
"(",
"pk",
")",
"result",
".",
"append",
"(",
"field",
".",
"cast_value",
"(",
"pk",
")",
")",
"else",
":",
"value",
"=",
"row",
"[",
"field",
".",
"name",
"]",
"if",
"field",
".",
"type",
"==",
"'number'",
"and",
"np",
".",
"isnan",
"(",
"value",
")",
":",
"value",
"=",
"None",
"if",
"value",
"and",
"field",
".",
"type",
"==",
"'integer'",
":",
"value",
"=",
"int",
"(",
"value",
")",
"elif",
"field",
".",
"type",
"==",
"'datetime'",
":",
"value",
"=",
"value",
".",
"to_pydatetime",
"(",
")",
"result",
".",
"append",
"(",
"field",
".",
"cast_value",
"(",
"value",
")",
")",
"return",
"result"
] |
Restore row from Pandas
|
[
"Restore",
"row",
"from",
"Pandas"
] |
ef941dbc12f5d346e9612f8fec1b4b356b8493ca
|
https://github.com/frictionlessdata/tableschema-pandas-py/blob/ef941dbc12f5d346e9612f8fec1b4b356b8493ca/tableschema_pandas/mapper.py#L156-L176
|
train
|
frictionlessdata/tableschema-pandas-py
|
tableschema_pandas/mapper.py
|
Mapper.restore_type
|
def restore_type(self, dtype, sample=None):
"""Restore type from Pandas
"""
# Pandas types
if pdc.is_bool_dtype(dtype):
return 'boolean'
elif pdc.is_datetime64_any_dtype(dtype):
return 'datetime'
elif pdc.is_integer_dtype(dtype):
return 'integer'
elif pdc.is_numeric_dtype(dtype):
return 'number'
# Python types
if sample is not None:
if isinstance(sample, (list, tuple)):
return 'array'
elif isinstance(sample, datetime.date):
return 'date'
elif isinstance(sample, isodate.Duration):
return 'duration'
elif isinstance(sample, dict):
return 'object'
elif isinstance(sample, six.string_types):
return 'string'
elif isinstance(sample, datetime.time):
return 'time'
return 'string'
|
python
|
def restore_type(self, dtype, sample=None):
"""Restore type from Pandas
"""
# Pandas types
if pdc.is_bool_dtype(dtype):
return 'boolean'
elif pdc.is_datetime64_any_dtype(dtype):
return 'datetime'
elif pdc.is_integer_dtype(dtype):
return 'integer'
elif pdc.is_numeric_dtype(dtype):
return 'number'
# Python types
if sample is not None:
if isinstance(sample, (list, tuple)):
return 'array'
elif isinstance(sample, datetime.date):
return 'date'
elif isinstance(sample, isodate.Duration):
return 'duration'
elif isinstance(sample, dict):
return 'object'
elif isinstance(sample, six.string_types):
return 'string'
elif isinstance(sample, datetime.time):
return 'time'
return 'string'
|
[
"def",
"restore_type",
"(",
"self",
",",
"dtype",
",",
"sample",
"=",
"None",
")",
":",
"# Pandas types",
"if",
"pdc",
".",
"is_bool_dtype",
"(",
"dtype",
")",
":",
"return",
"'boolean'",
"elif",
"pdc",
".",
"is_datetime64_any_dtype",
"(",
"dtype",
")",
":",
"return",
"'datetime'",
"elif",
"pdc",
".",
"is_integer_dtype",
"(",
"dtype",
")",
":",
"return",
"'integer'",
"elif",
"pdc",
".",
"is_numeric_dtype",
"(",
"dtype",
")",
":",
"return",
"'number'",
"# Python types",
"if",
"sample",
"is",
"not",
"None",
":",
"if",
"isinstance",
"(",
"sample",
",",
"(",
"list",
",",
"tuple",
")",
")",
":",
"return",
"'array'",
"elif",
"isinstance",
"(",
"sample",
",",
"datetime",
".",
"date",
")",
":",
"return",
"'date'",
"elif",
"isinstance",
"(",
"sample",
",",
"isodate",
".",
"Duration",
")",
":",
"return",
"'duration'",
"elif",
"isinstance",
"(",
"sample",
",",
"dict",
")",
":",
"return",
"'object'",
"elif",
"isinstance",
"(",
"sample",
",",
"six",
".",
"string_types",
")",
":",
"return",
"'string'",
"elif",
"isinstance",
"(",
"sample",
",",
"datetime",
".",
"time",
")",
":",
"return",
"'time'",
"return",
"'string'"
] |
Restore type from Pandas
|
[
"Restore",
"type",
"from",
"Pandas"
] |
ef941dbc12f5d346e9612f8fec1b4b356b8493ca
|
https://github.com/frictionlessdata/tableschema-pandas-py/blob/ef941dbc12f5d346e9612f8fec1b4b356b8493ca/tableschema_pandas/mapper.py#L178-L207
|
train
|
philgyford/django-spectator
|
spectator/core/templatetags/spectator_core.py
|
change_object_link_card
|
def change_object_link_card(obj, perms):
"""
If the user has permission to change `obj`, show a link to its Admin page.
obj -- An object like Movie, Play, ClassicalWork, Publication, etc.
perms -- The `perms` object that it's the template.
"""
# eg: 'movie' or 'classicalwork':
name = obj.__class__.__name__.lower()
permission = 'spectator.can_edit_{}'.format(name)
# eg: 'admin:events_classicalwork_change':
change_url_name = 'admin:{}_{}_change'.format(obj._meta.app_label, name)
return {
'display_link': (permission in perms),
'change_url': reverse(change_url_name, args=[obj.id])
}
|
python
|
def change_object_link_card(obj, perms):
"""
If the user has permission to change `obj`, show a link to its Admin page.
obj -- An object like Movie, Play, ClassicalWork, Publication, etc.
perms -- The `perms` object that it's the template.
"""
# eg: 'movie' or 'classicalwork':
name = obj.__class__.__name__.lower()
permission = 'spectator.can_edit_{}'.format(name)
# eg: 'admin:events_classicalwork_change':
change_url_name = 'admin:{}_{}_change'.format(obj._meta.app_label, name)
return {
'display_link': (permission in perms),
'change_url': reverse(change_url_name, args=[obj.id])
}
|
[
"def",
"change_object_link_card",
"(",
"obj",
",",
"perms",
")",
":",
"# eg: 'movie' or 'classicalwork':",
"name",
"=",
"obj",
".",
"__class__",
".",
"__name__",
".",
"lower",
"(",
")",
"permission",
"=",
"'spectator.can_edit_{}'",
".",
"format",
"(",
"name",
")",
"# eg: 'admin:events_classicalwork_change':",
"change_url_name",
"=",
"'admin:{}_{}_change'",
".",
"format",
"(",
"obj",
".",
"_meta",
".",
"app_label",
",",
"name",
")",
"return",
"{",
"'display_link'",
":",
"(",
"permission",
"in",
"perms",
")",
",",
"'change_url'",
":",
"reverse",
"(",
"change_url_name",
",",
"args",
"=",
"[",
"obj",
".",
"id",
"]",
")",
"}"
] |
If the user has permission to change `obj`, show a link to its Admin page.
obj -- An object like Movie, Play, ClassicalWork, Publication, etc.
perms -- The `perms` object that it's the template.
|
[
"If",
"the",
"user",
"has",
"permission",
"to",
"change",
"obj",
"show",
"a",
"link",
"to",
"its",
"Admin",
"page",
".",
"obj",
"--",
"An",
"object",
"like",
"Movie",
"Play",
"ClassicalWork",
"Publication",
"etc",
".",
"perms",
"--",
"The",
"perms",
"object",
"that",
"it",
"s",
"the",
"template",
"."
] |
f3c72004f9caa1fde0f5a3b2f0d2bf285fc01ada
|
https://github.com/philgyford/django-spectator/blob/f3c72004f9caa1fde0f5a3b2f0d2bf285fc01ada/spectator/core/templatetags/spectator_core.py#L49-L64
|
train
|
philgyford/django-spectator
|
spectator/core/templatetags/spectator_core.py
|
domain_urlize
|
def domain_urlize(value):
"""
Returns an HTML link to the supplied URL, but only using the domain as the
text. Strips 'www.' from the start of the domain, if present.
e.g. if `my_url` is 'http://www.example.org/foo/' then:
{{ my_url|domain_urlize }}
returns:
<a href="http://www.example.org/foo/" rel="nofollow">example.org</a>
"""
parsed_uri = urlparse(value)
domain = '{uri.netloc}'.format(uri=parsed_uri)
if domain.startswith('www.'):
domain = domain[4:]
return format_html('<a href="{}" rel="nofollow">{}</a>',
value,
domain
)
|
python
|
def domain_urlize(value):
"""
Returns an HTML link to the supplied URL, but only using the domain as the
text. Strips 'www.' from the start of the domain, if present.
e.g. if `my_url` is 'http://www.example.org/foo/' then:
{{ my_url|domain_urlize }}
returns:
<a href="http://www.example.org/foo/" rel="nofollow">example.org</a>
"""
parsed_uri = urlparse(value)
domain = '{uri.netloc}'.format(uri=parsed_uri)
if domain.startswith('www.'):
domain = domain[4:]
return format_html('<a href="{}" rel="nofollow">{}</a>',
value,
domain
)
|
[
"def",
"domain_urlize",
"(",
"value",
")",
":",
"parsed_uri",
"=",
"urlparse",
"(",
"value",
")",
"domain",
"=",
"'{uri.netloc}'",
".",
"format",
"(",
"uri",
"=",
"parsed_uri",
")",
"if",
"domain",
".",
"startswith",
"(",
"'www.'",
")",
":",
"domain",
"=",
"domain",
"[",
"4",
":",
"]",
"return",
"format_html",
"(",
"'<a href=\"{}\" rel=\"nofollow\">{}</a>'",
",",
"value",
",",
"domain",
")"
] |
Returns an HTML link to the supplied URL, but only using the domain as the
text. Strips 'www.' from the start of the domain, if present.
e.g. if `my_url` is 'http://www.example.org/foo/' then:
{{ my_url|domain_urlize }}
returns:
<a href="http://www.example.org/foo/" rel="nofollow">example.org</a>
|
[
"Returns",
"an",
"HTML",
"link",
"to",
"the",
"supplied",
"URL",
"but",
"only",
"using",
"the",
"domain",
"as",
"the",
"text",
".",
"Strips",
"www",
".",
"from",
"the",
"start",
"of",
"the",
"domain",
"if",
"present",
"."
] |
f3c72004f9caa1fde0f5a3b2f0d2bf285fc01ada
|
https://github.com/philgyford/django-spectator/blob/f3c72004f9caa1fde0f5a3b2f0d2bf285fc01ada/spectator/core/templatetags/spectator_core.py#L68-L89
|
train
|
philgyford/django-spectator
|
spectator/core/templatetags/spectator_core.py
|
current_url_name
|
def current_url_name(context):
"""
Returns the name of the current URL, namespaced, or False.
Example usage:
{% current_url_name as url_name %}
<a href="#"{% if url_name == 'myapp:home' %} class="active"{% endif %}">Home</a>
"""
url_name = False
if context.request.resolver_match:
url_name = "{}:{}".format(
context.request.resolver_match.namespace,
context.request.resolver_match.url_name
)
return url_name
|
python
|
def current_url_name(context):
"""
Returns the name of the current URL, namespaced, or False.
Example usage:
{% current_url_name as url_name %}
<a href="#"{% if url_name == 'myapp:home' %} class="active"{% endif %}">Home</a>
"""
url_name = False
if context.request.resolver_match:
url_name = "{}:{}".format(
context.request.resolver_match.namespace,
context.request.resolver_match.url_name
)
return url_name
|
[
"def",
"current_url_name",
"(",
"context",
")",
":",
"url_name",
"=",
"False",
"if",
"context",
".",
"request",
".",
"resolver_match",
":",
"url_name",
"=",
"\"{}:{}\"",
".",
"format",
"(",
"context",
".",
"request",
".",
"resolver_match",
".",
"namespace",
",",
"context",
".",
"request",
".",
"resolver_match",
".",
"url_name",
")",
"return",
"url_name"
] |
Returns the name of the current URL, namespaced, or False.
Example usage:
{% current_url_name as url_name %}
<a href="#"{% if url_name == 'myapp:home' %} class="active"{% endif %}">Home</a>
|
[
"Returns",
"the",
"name",
"of",
"the",
"current",
"URL",
"namespaced",
"or",
"False",
"."
] |
f3c72004f9caa1fde0f5a3b2f0d2bf285fc01ada
|
https://github.com/philgyford/django-spectator/blob/f3c72004f9caa1fde0f5a3b2f0d2bf285fc01ada/spectator/core/templatetags/spectator_core.py#L93-L110
|
train
|
philgyford/django-spectator
|
spectator/core/templatetags/spectator_core.py
|
query_string
|
def query_string(context, key, value):
"""
For adding/replacing a key=value pair to the GET string for a URL.
eg, if we're viewing ?p=3 and we do {% query_string order 'taken' %}
then this returns "p=3&order=taken"
And, if we're viewing ?p=3&order=uploaded and we do the same thing, we get
the same result (ie, the existing "order=uploaded" is replaced).
Expects the request object in context to do the above; otherwise it will
just return a query string with the supplied key=value pair.
"""
try:
request = context['request']
args = request.GET.copy()
except KeyError:
args = QueryDict('').copy()
args[key] = value
return args.urlencode()
|
python
|
def query_string(context, key, value):
"""
For adding/replacing a key=value pair to the GET string for a URL.
eg, if we're viewing ?p=3 and we do {% query_string order 'taken' %}
then this returns "p=3&order=taken"
And, if we're viewing ?p=3&order=uploaded and we do the same thing, we get
the same result (ie, the existing "order=uploaded" is replaced).
Expects the request object in context to do the above; otherwise it will
just return a query string with the supplied key=value pair.
"""
try:
request = context['request']
args = request.GET.copy()
except KeyError:
args = QueryDict('').copy()
args[key] = value
return args.urlencode()
|
[
"def",
"query_string",
"(",
"context",
",",
"key",
",",
"value",
")",
":",
"try",
":",
"request",
"=",
"context",
"[",
"'request'",
"]",
"args",
"=",
"request",
".",
"GET",
".",
"copy",
"(",
")",
"except",
"KeyError",
":",
"args",
"=",
"QueryDict",
"(",
"''",
")",
".",
"copy",
"(",
")",
"args",
"[",
"key",
"]",
"=",
"value",
"return",
"args",
".",
"urlencode",
"(",
")"
] |
For adding/replacing a key=value pair to the GET string for a URL.
eg, if we're viewing ?p=3 and we do {% query_string order 'taken' %}
then this returns "p=3&order=taken"
And, if we're viewing ?p=3&order=uploaded and we do the same thing, we get
the same result (ie, the existing "order=uploaded" is replaced).
Expects the request object in context to do the above; otherwise it will
just return a query string with the supplied key=value pair.
|
[
"For",
"adding",
"/",
"replacing",
"a",
"key",
"=",
"value",
"pair",
"to",
"the",
"GET",
"string",
"for",
"a",
"URL",
"."
] |
f3c72004f9caa1fde0f5a3b2f0d2bf285fc01ada
|
https://github.com/philgyford/django-spectator/blob/f3c72004f9caa1fde0f5a3b2f0d2bf285fc01ada/spectator/core/templatetags/spectator_core.py#L114-L133
|
train
|
philgyford/django-spectator
|
spectator/core/templatetags/spectator_core.py
|
most_read_creators_card
|
def most_read_creators_card(num=10):
"""
Displays a card showing the Creators who have the most Readings
associated with their Publications.
In spectator_core tags, rather than spectator_reading so it can still be
used on core pages, even if spectator_reading isn't installed.
"""
if spectator_apps.is_enabled('reading'):
object_list = most_read_creators(num=num)
object_list = chartify(object_list, 'num_readings', cutoff=1)
return {
'card_title': 'Most read authors',
'score_attr': 'num_readings',
'object_list': object_list,
}
|
python
|
def most_read_creators_card(num=10):
"""
Displays a card showing the Creators who have the most Readings
associated with their Publications.
In spectator_core tags, rather than spectator_reading so it can still be
used on core pages, even if spectator_reading isn't installed.
"""
if spectator_apps.is_enabled('reading'):
object_list = most_read_creators(num=num)
object_list = chartify(object_list, 'num_readings', cutoff=1)
return {
'card_title': 'Most read authors',
'score_attr': 'num_readings',
'object_list': object_list,
}
|
[
"def",
"most_read_creators_card",
"(",
"num",
"=",
"10",
")",
":",
"if",
"spectator_apps",
".",
"is_enabled",
"(",
"'reading'",
")",
":",
"object_list",
"=",
"most_read_creators",
"(",
"num",
"=",
"num",
")",
"object_list",
"=",
"chartify",
"(",
"object_list",
",",
"'num_readings'",
",",
"cutoff",
"=",
"1",
")",
"return",
"{",
"'card_title'",
":",
"'Most read authors'",
",",
"'score_attr'",
":",
"'num_readings'",
",",
"'object_list'",
":",
"object_list",
",",
"}"
] |
Displays a card showing the Creators who have the most Readings
associated with their Publications.
In spectator_core tags, rather than spectator_reading so it can still be
used on core pages, even if spectator_reading isn't installed.
|
[
"Displays",
"a",
"card",
"showing",
"the",
"Creators",
"who",
"have",
"the",
"most",
"Readings",
"associated",
"with",
"their",
"Publications",
"."
] |
f3c72004f9caa1fde0f5a3b2f0d2bf285fc01ada
|
https://github.com/philgyford/django-spectator/blob/f3c72004f9caa1fde0f5a3b2f0d2bf285fc01ada/spectator/core/templatetags/spectator_core.py#L149-L167
|
train
|
philgyford/django-spectator
|
spectator/core/templatetags/spectator_core.py
|
most_visited_venues_card
|
def most_visited_venues_card(num=10):
"""
Displays a card showing the Venues that have the most Events.
In spectator_core tags, rather than spectator_events so it can still be
used on core pages, even if spectator_events isn't installed.
"""
if spectator_apps.is_enabled('events'):
object_list = most_visited_venues(num=num)
object_list = chartify(object_list, 'num_visits', cutoff=1)
return {
'card_title': 'Most visited venues',
'score_attr': 'num_visits',
'object_list': object_list,
}
|
python
|
def most_visited_venues_card(num=10):
"""
Displays a card showing the Venues that have the most Events.
In spectator_core tags, rather than spectator_events so it can still be
used on core pages, even if spectator_events isn't installed.
"""
if spectator_apps.is_enabled('events'):
object_list = most_visited_venues(num=num)
object_list = chartify(object_list, 'num_visits', cutoff=1)
return {
'card_title': 'Most visited venues',
'score_attr': 'num_visits',
'object_list': object_list,
}
|
[
"def",
"most_visited_venues_card",
"(",
"num",
"=",
"10",
")",
":",
"if",
"spectator_apps",
".",
"is_enabled",
"(",
"'events'",
")",
":",
"object_list",
"=",
"most_visited_venues",
"(",
"num",
"=",
"num",
")",
"object_list",
"=",
"chartify",
"(",
"object_list",
",",
"'num_visits'",
",",
"cutoff",
"=",
"1",
")",
"return",
"{",
"'card_title'",
":",
"'Most visited venues'",
",",
"'score_attr'",
":",
"'num_visits'",
",",
"'object_list'",
":",
"object_list",
",",
"}"
] |
Displays a card showing the Venues that have the most Events.
In spectator_core tags, rather than spectator_events so it can still be
used on core pages, even if spectator_events isn't installed.
|
[
"Displays",
"a",
"card",
"showing",
"the",
"Venues",
"that",
"have",
"the",
"most",
"Events",
"."
] |
f3c72004f9caa1fde0f5a3b2f0d2bf285fc01ada
|
https://github.com/philgyford/django-spectator/blob/f3c72004f9caa1fde0f5a3b2f0d2bf285fc01ada/spectator/core/templatetags/spectator_core.py#L179-L196
|
train
|
philgyford/django-spectator
|
spectator/reading/models.py
|
Publication.has_urls
|
def has_urls(self):
"Handy for templates."
if self.isbn_uk or self.isbn_us or self.official_url or self.notes_url:
return True
else:
return False
|
python
|
def has_urls(self):
"Handy for templates."
if self.isbn_uk or self.isbn_us or self.official_url or self.notes_url:
return True
else:
return False
|
[
"def",
"has_urls",
"(",
"self",
")",
":",
"if",
"self",
".",
"isbn_uk",
"or",
"self",
".",
"isbn_us",
"or",
"self",
".",
"official_url",
"or",
"self",
".",
"notes_url",
":",
"return",
"True",
"else",
":",
"return",
"False"
] |
Handy for templates.
|
[
"Handy",
"for",
"templates",
"."
] |
f3c72004f9caa1fde0f5a3b2f0d2bf285fc01ada
|
https://github.com/philgyford/django-spectator/blob/f3c72004f9caa1fde0f5a3b2f0d2bf285fc01ada/spectator/reading/models.py#L169-L174
|
train
|
philgyford/django-spectator
|
setup.py
|
get_entity
|
def get_entity(package, entity):
"""
eg, get_entity('spectator', 'version') returns `__version__` value in
`__init__.py`.
"""
init_py = open(os.path.join(package, '__init__.py')).read()
find = "__%s__ = ['\"]([^'\"]+)['\"]" % entity
return re.search(find, init_py).group(1)
|
python
|
def get_entity(package, entity):
"""
eg, get_entity('spectator', 'version') returns `__version__` value in
`__init__.py`.
"""
init_py = open(os.path.join(package, '__init__.py')).read()
find = "__%s__ = ['\"]([^'\"]+)['\"]" % entity
return re.search(find, init_py).group(1)
|
[
"def",
"get_entity",
"(",
"package",
",",
"entity",
")",
":",
"init_py",
"=",
"open",
"(",
"os",
".",
"path",
".",
"join",
"(",
"package",
",",
"'__init__.py'",
")",
")",
".",
"read",
"(",
")",
"find",
"=",
"\"__%s__ = ['\\\"]([^'\\\"]+)['\\\"]\"",
"%",
"entity",
"return",
"re",
".",
"search",
"(",
"find",
",",
"init_py",
")",
".",
"group",
"(",
"1",
")"
] |
eg, get_entity('spectator', 'version') returns `__version__` value in
`__init__.py`.
|
[
"eg",
"get_entity",
"(",
"spectator",
"version",
")",
"returns",
"__version__",
"value",
"in",
"__init__",
".",
"py",
"."
] |
f3c72004f9caa1fde0f5a3b2f0d2bf285fc01ada
|
https://github.com/philgyford/django-spectator/blob/f3c72004f9caa1fde0f5a3b2f0d2bf285fc01ada/setup.py#L15-L22
|
train
|
philgyford/django-spectator
|
spectator/reading/views.py
|
ReadingYearArchiveView.get_queryset
|
def get_queryset(self):
"Reduce the number of queries and speed things up."
qs = super().get_queryset()
qs = qs.select_related('publication__series') \
.prefetch_related('publication__roles__creator')
return qs
|
python
|
def get_queryset(self):
"Reduce the number of queries and speed things up."
qs = super().get_queryset()
qs = qs.select_related('publication__series') \
.prefetch_related('publication__roles__creator')
return qs
|
[
"def",
"get_queryset",
"(",
"self",
")",
":",
"qs",
"=",
"super",
"(",
")",
".",
"get_queryset",
"(",
")",
"qs",
"=",
"qs",
".",
"select_related",
"(",
"'publication__series'",
")",
".",
"prefetch_related",
"(",
"'publication__roles__creator'",
")",
"return",
"qs"
] |
Reduce the number of queries and speed things up.
|
[
"Reduce",
"the",
"number",
"of",
"queries",
"and",
"speed",
"things",
"up",
"."
] |
f3c72004f9caa1fde0f5a3b2f0d2bf285fc01ada
|
https://github.com/philgyford/django-spectator/blob/f3c72004f9caa1fde0f5a3b2f0d2bf285fc01ada/spectator/reading/views.py#L122-L129
|
train
|
philgyford/django-spectator
|
spectator/core/migrations/0004_auto_20180102_0959.py
|
set_slug
|
def set_slug(apps, schema_editor):
"""
Create a slug for each Creator already in the DB.
"""
Creator = apps.get_model('spectator_core', 'Creator')
for c in Creator.objects.all():
c.slug = generate_slug(c.pk)
c.save(update_fields=['slug'])
|
python
|
def set_slug(apps, schema_editor):
"""
Create a slug for each Creator already in the DB.
"""
Creator = apps.get_model('spectator_core', 'Creator')
for c in Creator.objects.all():
c.slug = generate_slug(c.pk)
c.save(update_fields=['slug'])
|
[
"def",
"set_slug",
"(",
"apps",
",",
"schema_editor",
")",
":",
"Creator",
"=",
"apps",
".",
"get_model",
"(",
"'spectator_core'",
",",
"'Creator'",
")",
"for",
"c",
"in",
"Creator",
".",
"objects",
".",
"all",
"(",
")",
":",
"c",
".",
"slug",
"=",
"generate_slug",
"(",
"c",
".",
"pk",
")",
"c",
".",
"save",
"(",
"update_fields",
"=",
"[",
"'slug'",
"]",
")"
] |
Create a slug for each Creator already in the DB.
|
[
"Create",
"a",
"slug",
"for",
"each",
"Creator",
"already",
"in",
"the",
"DB",
"."
] |
f3c72004f9caa1fde0f5a3b2f0d2bf285fc01ada
|
https://github.com/philgyford/django-spectator/blob/f3c72004f9caa1fde0f5a3b2f0d2bf285fc01ada/spectator/core/migrations/0004_auto_20180102_0959.py#L24-L32
|
train
|
philgyford/django-spectator
|
spectator/events/migrations/0013_copy_classical_and_dance_data.py
|
forwards
|
def forwards(apps, schema_editor):
"""
Copy the ClassicalWork and DancePiece data to use the new through models.
"""
Event = apps.get_model('spectator_events', 'Event')
ClassicalWorkSelection = apps.get_model(
'spectator_events', 'ClassicalWorkSelection')
DancePieceSelection = apps.get_model(
'spectator_events', 'DancePieceSelection')
for event in Event.objects.all():
for work in event.classicalworks.all():
selection = ClassicalWorkSelection(
classical_work=work,
event=event)
selection.save()
for piece in event.dancepieces.all():
selection = DancePieceSelection(
dance_piece=piece,
event=event)
selection.save()
|
python
|
def forwards(apps, schema_editor):
"""
Copy the ClassicalWork and DancePiece data to use the new through models.
"""
Event = apps.get_model('spectator_events', 'Event')
ClassicalWorkSelection = apps.get_model(
'spectator_events', 'ClassicalWorkSelection')
DancePieceSelection = apps.get_model(
'spectator_events', 'DancePieceSelection')
for event in Event.objects.all():
for work in event.classicalworks.all():
selection = ClassicalWorkSelection(
classical_work=work,
event=event)
selection.save()
for piece in event.dancepieces.all():
selection = DancePieceSelection(
dance_piece=piece,
event=event)
selection.save()
|
[
"def",
"forwards",
"(",
"apps",
",",
"schema_editor",
")",
":",
"Event",
"=",
"apps",
".",
"get_model",
"(",
"'spectator_events'",
",",
"'Event'",
")",
"ClassicalWorkSelection",
"=",
"apps",
".",
"get_model",
"(",
"'spectator_events'",
",",
"'ClassicalWorkSelection'",
")",
"DancePieceSelection",
"=",
"apps",
".",
"get_model",
"(",
"'spectator_events'",
",",
"'DancePieceSelection'",
")",
"for",
"event",
"in",
"Event",
".",
"objects",
".",
"all",
"(",
")",
":",
"for",
"work",
"in",
"event",
".",
"classicalworks",
".",
"all",
"(",
")",
":",
"selection",
"=",
"ClassicalWorkSelection",
"(",
"classical_work",
"=",
"work",
",",
"event",
"=",
"event",
")",
"selection",
".",
"save",
"(",
")",
"for",
"piece",
"in",
"event",
".",
"dancepieces",
".",
"all",
"(",
")",
":",
"selection",
"=",
"DancePieceSelection",
"(",
"dance_piece",
"=",
"piece",
",",
"event",
"=",
"event",
")",
"selection",
".",
"save",
"(",
")"
] |
Copy the ClassicalWork and DancePiece data to use the new through models.
|
[
"Copy",
"the",
"ClassicalWork",
"and",
"DancePiece",
"data",
"to",
"use",
"the",
"new",
"through",
"models",
"."
] |
f3c72004f9caa1fde0f5a3b2f0d2bf285fc01ada
|
https://github.com/philgyford/django-spectator/blob/f3c72004f9caa1fde0f5a3b2f0d2bf285fc01ada/spectator/events/migrations/0013_copy_classical_and_dance_data.py#L6-L28
|
train
|
philgyford/django-spectator
|
spectator/events/migrations/0024_event_venue_name.py
|
forwards
|
def forwards(apps, schema_editor):
"""
Set the venue_name field of all Events that have a Venue.
"""
Event = apps.get_model('spectator_events', 'Event')
for event in Event.objects.all():
if event.venue is not None:
event.venue_name = event.venue.name
event.save()
|
python
|
def forwards(apps, schema_editor):
"""
Set the venue_name field of all Events that have a Venue.
"""
Event = apps.get_model('spectator_events', 'Event')
for event in Event.objects.all():
if event.venue is not None:
event.venue_name = event.venue.name
event.save()
|
[
"def",
"forwards",
"(",
"apps",
",",
"schema_editor",
")",
":",
"Event",
"=",
"apps",
".",
"get_model",
"(",
"'spectator_events'",
",",
"'Event'",
")",
"for",
"event",
"in",
"Event",
".",
"objects",
".",
"all",
"(",
")",
":",
"if",
"event",
".",
"venue",
"is",
"not",
"None",
":",
"event",
".",
"venue_name",
"=",
"event",
".",
"venue",
".",
"name",
"event",
".",
"save",
"(",
")"
] |
Set the venue_name field of all Events that have a Venue.
|
[
"Set",
"the",
"venue_name",
"field",
"of",
"all",
"Events",
"that",
"have",
"a",
"Venue",
"."
] |
f3c72004f9caa1fde0f5a3b2f0d2bf285fc01ada
|
https://github.com/philgyford/django-spectator/blob/f3c72004f9caa1fde0f5a3b2f0d2bf285fc01ada/spectator/events/migrations/0024_event_venue_name.py#L7-L16
|
train
|
philgyford/django-spectator
|
spectator/events/migrations/0037_exhibition_to_museum.py
|
forwards
|
def forwards(apps, schema_editor):
"""
Migrate all 'exhibition' Events to the new 'museum' Event kind.
"""
Event = apps.get_model('spectator_events', 'Event')
for ev in Event.objects.filter(kind='exhibition'):
ev.kind = 'museum'
ev.save()
|
python
|
def forwards(apps, schema_editor):
"""
Migrate all 'exhibition' Events to the new 'museum' Event kind.
"""
Event = apps.get_model('spectator_events', 'Event')
for ev in Event.objects.filter(kind='exhibition'):
ev.kind = 'museum'
ev.save()
|
[
"def",
"forwards",
"(",
"apps",
",",
"schema_editor",
")",
":",
"Event",
"=",
"apps",
".",
"get_model",
"(",
"'spectator_events'",
",",
"'Event'",
")",
"for",
"ev",
"in",
"Event",
".",
"objects",
".",
"filter",
"(",
"kind",
"=",
"'exhibition'",
")",
":",
"ev",
".",
"kind",
"=",
"'museum'",
"ev",
".",
"save",
"(",
")"
] |
Migrate all 'exhibition' Events to the new 'museum' Event kind.
|
[
"Migrate",
"all",
"exhibition",
"Events",
"to",
"the",
"new",
"museum",
"Event",
"kind",
"."
] |
f3c72004f9caa1fde0f5a3b2f0d2bf285fc01ada
|
https://github.com/philgyford/django-spectator/blob/f3c72004f9caa1fde0f5a3b2f0d2bf285fc01ada/spectator/events/migrations/0037_exhibition_to_museum.py#L6-L14
|
train
|
philgyford/django-spectator
|
spectator/core/utils.py
|
truncate_string
|
def truncate_string(text, strip_html=True, chars=255, truncate='…', at_word_boundary=False):
"""Truncate a string to a certain length, removing line breaks and mutliple
spaces, optionally removing HTML, and appending a 'truncate' string.
Keyword arguments:
strip_html -- boolean.
chars -- Number of characters to return.
at_word_boundary -- Only truncate at a word boundary, which will probably
result in a string shorter than chars.
truncate -- String to add to the end.
"""
if strip_html:
text = strip_tags(text)
text = text.replace('\n', ' ').replace('\r', '')
text = ' '.join(text.split())
if at_word_boundary:
if len(text) > chars:
text = text[:chars].rsplit(' ', 1)[0] + truncate
else:
text = Truncator(text).chars(chars, html=False, truncate=truncate)
return text
|
python
|
def truncate_string(text, strip_html=True, chars=255, truncate='…', at_word_boundary=False):
"""Truncate a string to a certain length, removing line breaks and mutliple
spaces, optionally removing HTML, and appending a 'truncate' string.
Keyword arguments:
strip_html -- boolean.
chars -- Number of characters to return.
at_word_boundary -- Only truncate at a word boundary, which will probably
result in a string shorter than chars.
truncate -- String to add to the end.
"""
if strip_html:
text = strip_tags(text)
text = text.replace('\n', ' ').replace('\r', '')
text = ' '.join(text.split())
if at_word_boundary:
if len(text) > chars:
text = text[:chars].rsplit(' ', 1)[0] + truncate
else:
text = Truncator(text).chars(chars, html=False, truncate=truncate)
return text
|
[
"def",
"truncate_string",
"(",
"text",
",",
"strip_html",
"=",
"True",
",",
"chars",
"=",
"255",
",",
"truncate",
"=",
"'…', ",
"a",
"_word_boundary=F",
"a",
"lse):",
"",
"",
"if",
"strip_html",
":",
"text",
"=",
"strip_tags",
"(",
"text",
")",
"text",
"=",
"text",
".",
"replace",
"(",
"'\\n'",
",",
"' '",
")",
".",
"replace",
"(",
"'\\r'",
",",
"''",
")",
"text",
"=",
"' '",
".",
"join",
"(",
"text",
".",
"split",
"(",
")",
")",
"if",
"at_word_boundary",
":",
"if",
"len",
"(",
"text",
")",
">",
"chars",
":",
"text",
"=",
"text",
"[",
":",
"chars",
"]",
".",
"rsplit",
"(",
"' '",
",",
"1",
")",
"[",
"0",
"]",
"+",
"truncate",
"else",
":",
"text",
"=",
"Truncator",
"(",
"text",
")",
".",
"chars",
"(",
"chars",
",",
"html",
"=",
"False",
",",
"truncate",
"=",
"truncate",
")",
"return",
"text"
] |
Truncate a string to a certain length, removing line breaks and mutliple
spaces, optionally removing HTML, and appending a 'truncate' string.
Keyword arguments:
strip_html -- boolean.
chars -- Number of characters to return.
at_word_boundary -- Only truncate at a word boundary, which will probably
result in a string shorter than chars.
truncate -- String to add to the end.
|
[
"Truncate",
"a",
"string",
"to",
"a",
"certain",
"length",
"removing",
"line",
"breaks",
"and",
"mutliple",
"spaces",
"optionally",
"removing",
"HTML",
"and",
"appending",
"a",
"truncate",
"string",
"."
] |
f3c72004f9caa1fde0f5a3b2f0d2bf285fc01ada
|
https://github.com/philgyford/django-spectator/blob/f3c72004f9caa1fde0f5a3b2f0d2bf285fc01ada/spectator/core/utils.py#L5-L25
|
train
|
philgyford/django-spectator
|
spectator/core/utils.py
|
chartify
|
def chartify(qs, score_field, cutoff=0, ensure_chartiness=True):
"""
Given a QuerySet it will go through and add a `chart_position` property to
each object returning a list of the objects.
If adjacent objects have the same 'score' (based on `score_field`) then
they will have the same `chart_position`. This can then be used in
templates for the `value` of <li> elements in an <ol>.
By default any objects with a score of 0 or less will be removed.
By default, if all the items in the chart have the same position, no items
will be returned (it's not much of a chart).
Keyword arguments:
qs -- The QuerySet
score_field -- The name of the numeric field that each object in the
QuerySet has, that will be used to compare their positions.
cutoff -- Any objects with a score of this value or below will be removed
from the list. Set to None to disable this.
ensure_chartiness -- If True, then if all items in the list have the same
score, an empty list will be returned.
"""
chart = []
position = 0
prev_obj = None
for counter, obj in enumerate(qs):
score = getattr(obj, score_field)
if score != getattr(prev_obj, score_field, None):
position = counter + 1
if cutoff is None or score > cutoff:
obj.chart_position = position
chart.append(obj)
prev_obj = obj
if ensure_chartiness and len(chart) > 0:
if getattr(chart[0], score_field) == getattr(chart[-1], score_field):
chart = []
return chart
|
python
|
def chartify(qs, score_field, cutoff=0, ensure_chartiness=True):
"""
Given a QuerySet it will go through and add a `chart_position` property to
each object returning a list of the objects.
If adjacent objects have the same 'score' (based on `score_field`) then
they will have the same `chart_position`. This can then be used in
templates for the `value` of <li> elements in an <ol>.
By default any objects with a score of 0 or less will be removed.
By default, if all the items in the chart have the same position, no items
will be returned (it's not much of a chart).
Keyword arguments:
qs -- The QuerySet
score_field -- The name of the numeric field that each object in the
QuerySet has, that will be used to compare their positions.
cutoff -- Any objects with a score of this value or below will be removed
from the list. Set to None to disable this.
ensure_chartiness -- If True, then if all items in the list have the same
score, an empty list will be returned.
"""
chart = []
position = 0
prev_obj = None
for counter, obj in enumerate(qs):
score = getattr(obj, score_field)
if score != getattr(prev_obj, score_field, None):
position = counter + 1
if cutoff is None or score > cutoff:
obj.chart_position = position
chart.append(obj)
prev_obj = obj
if ensure_chartiness and len(chart) > 0:
if getattr(chart[0], score_field) == getattr(chart[-1], score_field):
chart = []
return chart
|
[
"def",
"chartify",
"(",
"qs",
",",
"score_field",
",",
"cutoff",
"=",
"0",
",",
"ensure_chartiness",
"=",
"True",
")",
":",
"chart",
"=",
"[",
"]",
"position",
"=",
"0",
"prev_obj",
"=",
"None",
"for",
"counter",
",",
"obj",
"in",
"enumerate",
"(",
"qs",
")",
":",
"score",
"=",
"getattr",
"(",
"obj",
",",
"score_field",
")",
"if",
"score",
"!=",
"getattr",
"(",
"prev_obj",
",",
"score_field",
",",
"None",
")",
":",
"position",
"=",
"counter",
"+",
"1",
"if",
"cutoff",
"is",
"None",
"or",
"score",
">",
"cutoff",
":",
"obj",
".",
"chart_position",
"=",
"position",
"chart",
".",
"append",
"(",
"obj",
")",
"prev_obj",
"=",
"obj",
"if",
"ensure_chartiness",
"and",
"len",
"(",
"chart",
")",
">",
"0",
":",
"if",
"getattr",
"(",
"chart",
"[",
"0",
"]",
",",
"score_field",
")",
"==",
"getattr",
"(",
"chart",
"[",
"-",
"1",
"]",
",",
"score_field",
")",
":",
"chart",
"=",
"[",
"]",
"return",
"chart"
] |
Given a QuerySet it will go through and add a `chart_position` property to
each object returning a list of the objects.
If adjacent objects have the same 'score' (based on `score_field`) then
they will have the same `chart_position`. This can then be used in
templates for the `value` of <li> elements in an <ol>.
By default any objects with a score of 0 or less will be removed.
By default, if all the items in the chart have the same position, no items
will be returned (it's not much of a chart).
Keyword arguments:
qs -- The QuerySet
score_field -- The name of the numeric field that each object in the
QuerySet has, that will be used to compare their positions.
cutoff -- Any objects with a score of this value or below will be removed
from the list. Set to None to disable this.
ensure_chartiness -- If True, then if all items in the list have the same
score, an empty list will be returned.
|
[
"Given",
"a",
"QuerySet",
"it",
"will",
"go",
"through",
"and",
"add",
"a",
"chart_position",
"property",
"to",
"each",
"object",
"returning",
"a",
"list",
"of",
"the",
"objects",
"."
] |
f3c72004f9caa1fde0f5a3b2f0d2bf285fc01ada
|
https://github.com/philgyford/django-spectator/blob/f3c72004f9caa1fde0f5a3b2f0d2bf285fc01ada/spectator/core/utils.py#L28-L71
|
train
|
philgyford/django-spectator
|
spectator/events/managers.py
|
VenueManager.by_visits
|
def by_visits(self, event_kind=None):
"""
Gets Venues in order of how many Events have been held there.
Adds a `num_visits` field to each one.
event_kind filters by kind of Event, e.g. 'theatre', 'cinema', etc.
"""
qs = self.get_queryset()
if event_kind is not None:
qs = qs.filter(event__kind=event_kind)
qs = qs.annotate(num_visits=Count('event')) \
.order_by('-num_visits', 'name_sort')
return qs
|
python
|
def by_visits(self, event_kind=None):
"""
Gets Venues in order of how many Events have been held there.
Adds a `num_visits` field to each one.
event_kind filters by kind of Event, e.g. 'theatre', 'cinema', etc.
"""
qs = self.get_queryset()
if event_kind is not None:
qs = qs.filter(event__kind=event_kind)
qs = qs.annotate(num_visits=Count('event')) \
.order_by('-num_visits', 'name_sort')
return qs
|
[
"def",
"by_visits",
"(",
"self",
",",
"event_kind",
"=",
"None",
")",
":",
"qs",
"=",
"self",
".",
"get_queryset",
"(",
")",
"if",
"event_kind",
"is",
"not",
"None",
":",
"qs",
"=",
"qs",
".",
"filter",
"(",
"event__kind",
"=",
"event_kind",
")",
"qs",
"=",
"qs",
".",
"annotate",
"(",
"num_visits",
"=",
"Count",
"(",
"'event'",
")",
")",
".",
"order_by",
"(",
"'-num_visits'",
",",
"'name_sort'",
")",
"return",
"qs"
] |
Gets Venues in order of how many Events have been held there.
Adds a `num_visits` field to each one.
event_kind filters by kind of Event, e.g. 'theatre', 'cinema', etc.
|
[
"Gets",
"Venues",
"in",
"order",
"of",
"how",
"many",
"Events",
"have",
"been",
"held",
"there",
".",
"Adds",
"a",
"num_visits",
"field",
"to",
"each",
"one",
"."
] |
f3c72004f9caa1fde0f5a3b2f0d2bf285fc01ada
|
https://github.com/philgyford/django-spectator/blob/f3c72004f9caa1fde0f5a3b2f0d2bf285fc01ada/spectator/events/managers.py#L7-L22
|
train
|
philgyford/django-spectator
|
spectator/events/managers.py
|
WorkManager.by_views
|
def by_views(self, kind=None):
"""
Gets Works in order of how many times they've been attached to
Events.
kind is the kind of Work, e.g. 'play', 'movie', etc.
"""
qs = self.get_queryset()
if kind is not None:
qs = qs.filter(kind=kind)
qs = qs.annotate(num_views=Count('event')) \
.order_by('-num_views', 'title_sort')
return qs
|
python
|
def by_views(self, kind=None):
"""
Gets Works in order of how many times they've been attached to
Events.
kind is the kind of Work, e.g. 'play', 'movie', etc.
"""
qs = self.get_queryset()
if kind is not None:
qs = qs.filter(kind=kind)
qs = qs.annotate(num_views=Count('event')) \
.order_by('-num_views', 'title_sort')
return qs
|
[
"def",
"by_views",
"(",
"self",
",",
"kind",
"=",
"None",
")",
":",
"qs",
"=",
"self",
".",
"get_queryset",
"(",
")",
"if",
"kind",
"is",
"not",
"None",
":",
"qs",
"=",
"qs",
".",
"filter",
"(",
"kind",
"=",
"kind",
")",
"qs",
"=",
"qs",
".",
"annotate",
"(",
"num_views",
"=",
"Count",
"(",
"'event'",
")",
")",
".",
"order_by",
"(",
"'-num_views'",
",",
"'title_sort'",
")",
"return",
"qs"
] |
Gets Works in order of how many times they've been attached to
Events.
kind is the kind of Work, e.g. 'play', 'movie', etc.
|
[
"Gets",
"Works",
"in",
"order",
"of",
"how",
"many",
"times",
"they",
"ve",
"been",
"attached",
"to",
"Events",
"."
] |
f3c72004f9caa1fde0f5a3b2f0d2bf285fc01ada
|
https://github.com/philgyford/django-spectator/blob/f3c72004f9caa1fde0f5a3b2f0d2bf285fc01ada/spectator/events/managers.py#L27-L42
|
train
|
philgyford/django-spectator
|
spectator/core/fields.py
|
NaturalSortField.naturalize_thing
|
def naturalize_thing(self, string):
"""
Make a naturalized version of a general string, not a person's name.
e.g., title of a book, a band's name, etc.
string -- a lowercase string.
"""
# Things we want to move to the back of the string:
articles = [
'a', 'an', 'the',
'un', 'une', 'le', 'la', 'les', "l'", "l’",
'ein', 'eine', 'der', 'die', 'das',
'una', 'el', 'los', 'las',
]
sort_string = string
parts = string.split(' ')
if len(parts) > 1 and parts[0] in articles:
if parts[0] != parts[1]:
# Don't do this if the name is 'The The' or 'La La Land'.
# Makes 'long blondes, the':
sort_string = '{}, {}'.format(' '.join(parts[1:]), parts[0])
sort_string = self._naturalize_numbers(sort_string)
return sort_string
|
python
|
def naturalize_thing(self, string):
"""
Make a naturalized version of a general string, not a person's name.
e.g., title of a book, a band's name, etc.
string -- a lowercase string.
"""
# Things we want to move to the back of the string:
articles = [
'a', 'an', 'the',
'un', 'une', 'le', 'la', 'les', "l'", "l’",
'ein', 'eine', 'der', 'die', 'das',
'una', 'el', 'los', 'las',
]
sort_string = string
parts = string.split(' ')
if len(parts) > 1 and parts[0] in articles:
if parts[0] != parts[1]:
# Don't do this if the name is 'The The' or 'La La Land'.
# Makes 'long blondes, the':
sort_string = '{}, {}'.format(' '.join(parts[1:]), parts[0])
sort_string = self._naturalize_numbers(sort_string)
return sort_string
|
[
"def",
"naturalize_thing",
"(",
"self",
",",
"string",
")",
":",
"# Things we want to move to the back of the string:",
"articles",
"=",
"[",
"'a'",
",",
"'an'",
",",
"'the'",
",",
"'un'",
",",
"'une'",
",",
"'le'",
",",
"'la'",
",",
"'les'",
",",
"\"l'\"",
",",
"\"l’\",",
"",
"'ein'",
",",
"'eine'",
",",
"'der'",
",",
"'die'",
",",
"'das'",
",",
"'una'",
",",
"'el'",
",",
"'los'",
",",
"'las'",
",",
"]",
"sort_string",
"=",
"string",
"parts",
"=",
"string",
".",
"split",
"(",
"' '",
")",
"if",
"len",
"(",
"parts",
")",
">",
"1",
"and",
"parts",
"[",
"0",
"]",
"in",
"articles",
":",
"if",
"parts",
"[",
"0",
"]",
"!=",
"parts",
"[",
"1",
"]",
":",
"# Don't do this if the name is 'The The' or 'La La Land'.",
"# Makes 'long blondes, the':",
"sort_string",
"=",
"'{}, {}'",
".",
"format",
"(",
"' '",
".",
"join",
"(",
"parts",
"[",
"1",
":",
"]",
")",
",",
"parts",
"[",
"0",
"]",
")",
"sort_string",
"=",
"self",
".",
"_naturalize_numbers",
"(",
"sort_string",
")",
"return",
"sort_string"
] |
Make a naturalized version of a general string, not a person's name.
e.g., title of a book, a band's name, etc.
string -- a lowercase string.
|
[
"Make",
"a",
"naturalized",
"version",
"of",
"a",
"general",
"string",
"not",
"a",
"person",
"s",
"name",
".",
"e",
".",
"g",
".",
"title",
"of",
"a",
"book",
"a",
"band",
"s",
"name",
"etc",
"."
] |
f3c72004f9caa1fde0f5a3b2f0d2bf285fc01ada
|
https://github.com/philgyford/django-spectator/blob/f3c72004f9caa1fde0f5a3b2f0d2bf285fc01ada/spectator/core/fields.py#L147-L174
|
train
|
philgyford/django-spectator
|
spectator/core/fields.py
|
NaturalSortField.naturalize_person
|
def naturalize_person(self, string):
"""
Attempt to make a version of the string that has the surname, if any,
at the start.
'John, Brown' to 'Brown, John'
'Sir John Brown Jr' to 'Brown, Sir John Jr'
'Prince' to 'Prince'
string -- The string to change.
"""
suffixes = [
'Jr', 'Jr.', 'Sr', 'Sr.',
'I', 'II', 'III', 'IV', 'V',
]
# Add lowercase versions:
suffixes = suffixes + [s.lower() for s in suffixes]
# If a name has a capitalised particle in we use that to sort.
# So 'Le Carre, John' but 'Carre, John le'.
particles = [
'Le', 'La',
'Von', 'Van',
'Du', 'De',
]
surname = '' # Smith
names = '' # Fred James
suffix = '' # Jr
sort_string = string
parts = string.split(' ')
if parts[-1] in suffixes:
# Remove suffixes entirely, as we'll add them back on the end.
suffix = parts[-1]
parts = parts[0:-1] # Remove suffix from parts
sort_string = ' '.join(parts)
if len(parts) > 1:
if parts[-2] in particles:
# From ['Alan', 'Barry', 'Le', 'Carré']
# to ['Alan', 'Barry', 'Le Carré']:
parts = parts[0:-2] + [ ' '.join(parts[-2:]) ]
# From 'David Foster Wallace' to 'Wallace, David Foster':
sort_string = '{}, {}'.format(parts[-1], ' '.join(parts[:-1]))
if suffix:
# Add it back on.
sort_string = '{} {}'.format(sort_string, suffix)
# In case this name has any numbers in it.
sort_string = self._naturalize_numbers(sort_string)
return sort_string
|
python
|
def naturalize_person(self, string):
"""
Attempt to make a version of the string that has the surname, if any,
at the start.
'John, Brown' to 'Brown, John'
'Sir John Brown Jr' to 'Brown, Sir John Jr'
'Prince' to 'Prince'
string -- The string to change.
"""
suffixes = [
'Jr', 'Jr.', 'Sr', 'Sr.',
'I', 'II', 'III', 'IV', 'V',
]
# Add lowercase versions:
suffixes = suffixes + [s.lower() for s in suffixes]
# If a name has a capitalised particle in we use that to sort.
# So 'Le Carre, John' but 'Carre, John le'.
particles = [
'Le', 'La',
'Von', 'Van',
'Du', 'De',
]
surname = '' # Smith
names = '' # Fred James
suffix = '' # Jr
sort_string = string
parts = string.split(' ')
if parts[-1] in suffixes:
# Remove suffixes entirely, as we'll add them back on the end.
suffix = parts[-1]
parts = parts[0:-1] # Remove suffix from parts
sort_string = ' '.join(parts)
if len(parts) > 1:
if parts[-2] in particles:
# From ['Alan', 'Barry', 'Le', 'Carré']
# to ['Alan', 'Barry', 'Le Carré']:
parts = parts[0:-2] + [ ' '.join(parts[-2:]) ]
# From 'David Foster Wallace' to 'Wallace, David Foster':
sort_string = '{}, {}'.format(parts[-1], ' '.join(parts[:-1]))
if suffix:
# Add it back on.
sort_string = '{} {}'.format(sort_string, suffix)
# In case this name has any numbers in it.
sort_string = self._naturalize_numbers(sort_string)
return sort_string
|
[
"def",
"naturalize_person",
"(",
"self",
",",
"string",
")",
":",
"suffixes",
"=",
"[",
"'Jr'",
",",
"'Jr.'",
",",
"'Sr'",
",",
"'Sr.'",
",",
"'I'",
",",
"'II'",
",",
"'III'",
",",
"'IV'",
",",
"'V'",
",",
"]",
"# Add lowercase versions:",
"suffixes",
"=",
"suffixes",
"+",
"[",
"s",
".",
"lower",
"(",
")",
"for",
"s",
"in",
"suffixes",
"]",
"# If a name has a capitalised particle in we use that to sort.",
"# So 'Le Carre, John' but 'Carre, John le'.",
"particles",
"=",
"[",
"'Le'",
",",
"'La'",
",",
"'Von'",
",",
"'Van'",
",",
"'Du'",
",",
"'De'",
",",
"]",
"surname",
"=",
"''",
"# Smith",
"names",
"=",
"''",
"# Fred James",
"suffix",
"=",
"''",
"# Jr",
"sort_string",
"=",
"string",
"parts",
"=",
"string",
".",
"split",
"(",
"' '",
")",
"if",
"parts",
"[",
"-",
"1",
"]",
"in",
"suffixes",
":",
"# Remove suffixes entirely, as we'll add them back on the end.",
"suffix",
"=",
"parts",
"[",
"-",
"1",
"]",
"parts",
"=",
"parts",
"[",
"0",
":",
"-",
"1",
"]",
"# Remove suffix from parts",
"sort_string",
"=",
"' '",
".",
"join",
"(",
"parts",
")",
"if",
"len",
"(",
"parts",
")",
">",
"1",
":",
"if",
"parts",
"[",
"-",
"2",
"]",
"in",
"particles",
":",
"# From ['Alan', 'Barry', 'Le', 'Carré']",
"# to ['Alan', 'Barry', 'Le Carré']:",
"parts",
"=",
"parts",
"[",
"0",
":",
"-",
"2",
"]",
"+",
"[",
"' '",
".",
"join",
"(",
"parts",
"[",
"-",
"2",
":",
"]",
")",
"]",
"# From 'David Foster Wallace' to 'Wallace, David Foster':",
"sort_string",
"=",
"'{}, {}'",
".",
"format",
"(",
"parts",
"[",
"-",
"1",
"]",
",",
"' '",
".",
"join",
"(",
"parts",
"[",
":",
"-",
"1",
"]",
")",
")",
"if",
"suffix",
":",
"# Add it back on.",
"sort_string",
"=",
"'{} {}'",
".",
"format",
"(",
"sort_string",
",",
"suffix",
")",
"# In case this name has any numbers in it.",
"sort_string",
"=",
"self",
".",
"_naturalize_numbers",
"(",
"sort_string",
")",
"return",
"sort_string"
] |
Attempt to make a version of the string that has the surname, if any,
at the start.
'John, Brown' to 'Brown, John'
'Sir John Brown Jr' to 'Brown, Sir John Jr'
'Prince' to 'Prince'
string -- The string to change.
|
[
"Attempt",
"to",
"make",
"a",
"version",
"of",
"the",
"string",
"that",
"has",
"the",
"surname",
"if",
"any",
"at",
"the",
"start",
"."
] |
f3c72004f9caa1fde0f5a3b2f0d2bf285fc01ada
|
https://github.com/philgyford/django-spectator/blob/f3c72004f9caa1fde0f5a3b2f0d2bf285fc01ada/spectator/core/fields.py#L176-L232
|
train
|
philgyford/django-spectator
|
spectator/core/fields.py
|
NaturalSortField._naturalize_numbers
|
def _naturalize_numbers(self, string):
"""
Makes any integers into very zero-padded numbers.
e.g. '1' becomes '00000001'.
"""
def naturalize_int_match(match):
return '%08d' % (int(match.group(0)),)
string = re.sub(r'\d+', naturalize_int_match, string)
return string
|
python
|
def _naturalize_numbers(self, string):
"""
Makes any integers into very zero-padded numbers.
e.g. '1' becomes '00000001'.
"""
def naturalize_int_match(match):
return '%08d' % (int(match.group(0)),)
string = re.sub(r'\d+', naturalize_int_match, string)
return string
|
[
"def",
"_naturalize_numbers",
"(",
"self",
",",
"string",
")",
":",
"def",
"naturalize_int_match",
"(",
"match",
")",
":",
"return",
"'%08d'",
"%",
"(",
"int",
"(",
"match",
".",
"group",
"(",
"0",
")",
")",
",",
")",
"string",
"=",
"re",
".",
"sub",
"(",
"r'\\d+'",
",",
"naturalize_int_match",
",",
"string",
")",
"return",
"string"
] |
Makes any integers into very zero-padded numbers.
e.g. '1' becomes '00000001'.
|
[
"Makes",
"any",
"integers",
"into",
"very",
"zero",
"-",
"padded",
"numbers",
".",
"e",
".",
"g",
".",
"1",
"becomes",
"00000001",
"."
] |
f3c72004f9caa1fde0f5a3b2f0d2bf285fc01ada
|
https://github.com/philgyford/django-spectator/blob/f3c72004f9caa1fde0f5a3b2f0d2bf285fc01ada/spectator/core/fields.py#L234-L245
|
train
|
philgyford/django-spectator
|
spectator/reading/utils.py
|
annual_reading_counts
|
def annual_reading_counts(kind='all'):
"""
Returns a list of dicts, one per year of reading. In year order.
Each dict is like this (if kind is 'all'):
{'year': datetime.date(2003, 1, 1),
'book': 12, # only included if kind is 'all' or 'book'
'periodical': 18, # only included if kind is 'all' or 'periodical'
'total': 30, # only included if kind is 'all'
}
We use the end_date of a Reading to count when that thing was read.
kind is one of 'book', 'periodical' or 'all', for both.
"""
if kind == 'all':
kinds = ['book', 'periodical']
else:
kinds = [kind]
# This will have keys of years (strings) and dicts of data:
# {
# '2003': {'books': 12, 'periodicals': 18},
# }
counts = OrderedDict()
for k in kinds:
qs = Reading.objects.exclude(end_date__isnull=True) \
.filter(publication__kind=k) \
.annotate(year=TruncYear('end_date')) \
.values('year') \
.annotate(count=Count('id')) \
.order_by('year')
for year_data in qs:
year_str = year_data['year'].strftime('%Y')
if not year_str in counts:
counts[year_str] = {
'year': year_data['year'],
}
counts[year_str][k] = year_data['count']
# Now translate counts into our final list, with totals, and 0s for kinds
# when they have no Readings for that year.
counts_list = []
for year_str, data in counts.items():
year_data = {
'year': data['year'],
}
if kind == 'all':
year_data['total'] = 0
for k in kinds:
if k in data:
year_data[k] = data[k]
if kind == 'all':
year_data['total'] += data[k]
else:
year_data[k] = 0
counts_list.append(year_data)
return counts_list
|
python
|
def annual_reading_counts(kind='all'):
"""
Returns a list of dicts, one per year of reading. In year order.
Each dict is like this (if kind is 'all'):
{'year': datetime.date(2003, 1, 1),
'book': 12, # only included if kind is 'all' or 'book'
'periodical': 18, # only included if kind is 'all' or 'periodical'
'total': 30, # only included if kind is 'all'
}
We use the end_date of a Reading to count when that thing was read.
kind is one of 'book', 'periodical' or 'all', for both.
"""
if kind == 'all':
kinds = ['book', 'periodical']
else:
kinds = [kind]
# This will have keys of years (strings) and dicts of data:
# {
# '2003': {'books': 12, 'periodicals': 18},
# }
counts = OrderedDict()
for k in kinds:
qs = Reading.objects.exclude(end_date__isnull=True) \
.filter(publication__kind=k) \
.annotate(year=TruncYear('end_date')) \
.values('year') \
.annotate(count=Count('id')) \
.order_by('year')
for year_data in qs:
year_str = year_data['year'].strftime('%Y')
if not year_str in counts:
counts[year_str] = {
'year': year_data['year'],
}
counts[year_str][k] = year_data['count']
# Now translate counts into our final list, with totals, and 0s for kinds
# when they have no Readings for that year.
counts_list = []
for year_str, data in counts.items():
year_data = {
'year': data['year'],
}
if kind == 'all':
year_data['total'] = 0
for k in kinds:
if k in data:
year_data[k] = data[k]
if kind == 'all':
year_data['total'] += data[k]
else:
year_data[k] = 0
counts_list.append(year_data)
return counts_list
|
[
"def",
"annual_reading_counts",
"(",
"kind",
"=",
"'all'",
")",
":",
"if",
"kind",
"==",
"'all'",
":",
"kinds",
"=",
"[",
"'book'",
",",
"'periodical'",
"]",
"else",
":",
"kinds",
"=",
"[",
"kind",
"]",
"# This will have keys of years (strings) and dicts of data:",
"# {",
"# '2003': {'books': 12, 'periodicals': 18},",
"# }",
"counts",
"=",
"OrderedDict",
"(",
")",
"for",
"k",
"in",
"kinds",
":",
"qs",
"=",
"Reading",
".",
"objects",
".",
"exclude",
"(",
"end_date__isnull",
"=",
"True",
")",
".",
"filter",
"(",
"publication__kind",
"=",
"k",
")",
".",
"annotate",
"(",
"year",
"=",
"TruncYear",
"(",
"'end_date'",
")",
")",
".",
"values",
"(",
"'year'",
")",
".",
"annotate",
"(",
"count",
"=",
"Count",
"(",
"'id'",
")",
")",
".",
"order_by",
"(",
"'year'",
")",
"for",
"year_data",
"in",
"qs",
":",
"year_str",
"=",
"year_data",
"[",
"'year'",
"]",
".",
"strftime",
"(",
"'%Y'",
")",
"if",
"not",
"year_str",
"in",
"counts",
":",
"counts",
"[",
"year_str",
"]",
"=",
"{",
"'year'",
":",
"year_data",
"[",
"'year'",
"]",
",",
"}",
"counts",
"[",
"year_str",
"]",
"[",
"k",
"]",
"=",
"year_data",
"[",
"'count'",
"]",
"# Now translate counts into our final list, with totals, and 0s for kinds",
"# when they have no Readings for that year.",
"counts_list",
"=",
"[",
"]",
"for",
"year_str",
",",
"data",
"in",
"counts",
".",
"items",
"(",
")",
":",
"year_data",
"=",
"{",
"'year'",
":",
"data",
"[",
"'year'",
"]",
",",
"}",
"if",
"kind",
"==",
"'all'",
":",
"year_data",
"[",
"'total'",
"]",
"=",
"0",
"for",
"k",
"in",
"kinds",
":",
"if",
"k",
"in",
"data",
":",
"year_data",
"[",
"k",
"]",
"=",
"data",
"[",
"k",
"]",
"if",
"kind",
"==",
"'all'",
":",
"year_data",
"[",
"'total'",
"]",
"+=",
"data",
"[",
"k",
"]",
"else",
":",
"year_data",
"[",
"k",
"]",
"=",
"0",
"counts_list",
".",
"append",
"(",
"year_data",
")",
"return",
"counts_list"
] |
Returns a list of dicts, one per year of reading. In year order.
Each dict is like this (if kind is 'all'):
{'year': datetime.date(2003, 1, 1),
'book': 12, # only included if kind is 'all' or 'book'
'periodical': 18, # only included if kind is 'all' or 'periodical'
'total': 30, # only included if kind is 'all'
}
We use the end_date of a Reading to count when that thing was read.
kind is one of 'book', 'periodical' or 'all', for both.
|
[
"Returns",
"a",
"list",
"of",
"dicts",
"one",
"per",
"year",
"of",
"reading",
".",
"In",
"year",
"order",
".",
"Each",
"dict",
"is",
"like",
"this",
"(",
"if",
"kind",
"is",
"all",
")",
":"
] |
f3c72004f9caa1fde0f5a3b2f0d2bf285fc01ada
|
https://github.com/philgyford/django-spectator/blob/f3c72004f9caa1fde0f5a3b2f0d2bf285fc01ada/spectator/reading/utils.py#L9-L73
|
train
|
philgyford/django-spectator
|
spectator/events/admin.py
|
CountryListFilter.lookups
|
def lookups(self, request, model_admin):
"""
Returns a list of tuples like:
[
('AU', 'Australia'),
('GB', 'UK'),
('US', 'USA'),
]
One for each country that has at least one Venue.
Sorted by the label names.
"""
list_of_countries = []
# We don't need the country_count but we need to annotate them in order
# to group the results.
qs = Venue.objects.exclude(country='') \
.values('country') \
.annotate(country_count=Count('country')) \
.order_by('country')
for obj in qs:
country = obj['country']
list_of_countries.append(
(country, Venue.COUNTRIES[country])
)
return sorted(list_of_countries, key=lambda c: c[1])
|
python
|
def lookups(self, request, model_admin):
"""
Returns a list of tuples like:
[
('AU', 'Australia'),
('GB', 'UK'),
('US', 'USA'),
]
One for each country that has at least one Venue.
Sorted by the label names.
"""
list_of_countries = []
# We don't need the country_count but we need to annotate them in order
# to group the results.
qs = Venue.objects.exclude(country='') \
.values('country') \
.annotate(country_count=Count('country')) \
.order_by('country')
for obj in qs:
country = obj['country']
list_of_countries.append(
(country, Venue.COUNTRIES[country])
)
return sorted(list_of_countries, key=lambda c: c[1])
|
[
"def",
"lookups",
"(",
"self",
",",
"request",
",",
"model_admin",
")",
":",
"list_of_countries",
"=",
"[",
"]",
"# We don't need the country_count but we need to annotate them in order",
"# to group the results.",
"qs",
"=",
"Venue",
".",
"objects",
".",
"exclude",
"(",
"country",
"=",
"''",
")",
".",
"values",
"(",
"'country'",
")",
".",
"annotate",
"(",
"country_count",
"=",
"Count",
"(",
"'country'",
")",
")",
".",
"order_by",
"(",
"'country'",
")",
"for",
"obj",
"in",
"qs",
":",
"country",
"=",
"obj",
"[",
"'country'",
"]",
"list_of_countries",
".",
"append",
"(",
"(",
"country",
",",
"Venue",
".",
"COUNTRIES",
"[",
"country",
"]",
")",
")",
"return",
"sorted",
"(",
"list_of_countries",
",",
"key",
"=",
"lambda",
"c",
":",
"c",
"[",
"1",
"]",
")"
] |
Returns a list of tuples like:
[
('AU', 'Australia'),
('GB', 'UK'),
('US', 'USA'),
]
One for each country that has at least one Venue.
Sorted by the label names.
|
[
"Returns",
"a",
"list",
"of",
"tuples",
"like",
":"
] |
f3c72004f9caa1fde0f5a3b2f0d2bf285fc01ada
|
https://github.com/philgyford/django-spectator/blob/f3c72004f9caa1fde0f5a3b2f0d2bf285fc01ada/spectator/events/admin.py#L120-L147
|
train
|
philgyford/django-spectator
|
spectator/events/admin.py
|
CountryListFilter.queryset
|
def queryset(self, request, queryset):
"""
Returns the filtered queryset based on the value
provided in the query string and retrievable via
`self.value()`.
"""
if self.value():
return queryset.filter(country=self.value())
else:
return queryset
|
python
|
def queryset(self, request, queryset):
"""
Returns the filtered queryset based on the value
provided in the query string and retrievable via
`self.value()`.
"""
if self.value():
return queryset.filter(country=self.value())
else:
return queryset
|
[
"def",
"queryset",
"(",
"self",
",",
"request",
",",
"queryset",
")",
":",
"if",
"self",
".",
"value",
"(",
")",
":",
"return",
"queryset",
".",
"filter",
"(",
"country",
"=",
"self",
".",
"value",
"(",
")",
")",
"else",
":",
"return",
"queryset"
] |
Returns the filtered queryset based on the value
provided in the query string and retrievable via
`self.value()`.
|
[
"Returns",
"the",
"filtered",
"queryset",
"based",
"on",
"the",
"value",
"provided",
"in",
"the",
"query",
"string",
"and",
"retrievable",
"via",
"self",
".",
"value",
"()",
"."
] |
f3c72004f9caa1fde0f5a3b2f0d2bf285fc01ada
|
https://github.com/philgyford/django-spectator/blob/f3c72004f9caa1fde0f5a3b2f0d2bf285fc01ada/spectator/events/admin.py#L149-L158
|
train
|
philgyford/django-spectator
|
spectator/events/migrations/0017_copy_movies_and_plays_data.py
|
forward
|
def forward(apps, schema_editor):
"""
Copying data from the old `Event.movie` and `Event.play` ForeignKey fields
into the new `Event.movies` and `Event.plays` ManyToManyFields.
"""
Event = apps.get_model('spectator_events', 'Event')
MovieSelection = apps.get_model('spectator_events', 'MovieSelection')
PlaySelection = apps.get_model('spectator_events', 'PlaySelection')
for event in Event.objects.all():
if event.movie is not None:
selection = MovieSelection(event=event, movie=event.movie)
selection.save()
if event.play is not None:
selection = PlaySelection(event=event, play=event.play)
selection.save()
|
python
|
def forward(apps, schema_editor):
"""
Copying data from the old `Event.movie` and `Event.play` ForeignKey fields
into the new `Event.movies` and `Event.plays` ManyToManyFields.
"""
Event = apps.get_model('spectator_events', 'Event')
MovieSelection = apps.get_model('spectator_events', 'MovieSelection')
PlaySelection = apps.get_model('spectator_events', 'PlaySelection')
for event in Event.objects.all():
if event.movie is not None:
selection = MovieSelection(event=event, movie=event.movie)
selection.save()
if event.play is not None:
selection = PlaySelection(event=event, play=event.play)
selection.save()
|
[
"def",
"forward",
"(",
"apps",
",",
"schema_editor",
")",
":",
"Event",
"=",
"apps",
".",
"get_model",
"(",
"'spectator_events'",
",",
"'Event'",
")",
"MovieSelection",
"=",
"apps",
".",
"get_model",
"(",
"'spectator_events'",
",",
"'MovieSelection'",
")",
"PlaySelection",
"=",
"apps",
".",
"get_model",
"(",
"'spectator_events'",
",",
"'PlaySelection'",
")",
"for",
"event",
"in",
"Event",
".",
"objects",
".",
"all",
"(",
")",
":",
"if",
"event",
".",
"movie",
"is",
"not",
"None",
":",
"selection",
"=",
"MovieSelection",
"(",
"event",
"=",
"event",
",",
"movie",
"=",
"event",
".",
"movie",
")",
"selection",
".",
"save",
"(",
")",
"if",
"event",
".",
"play",
"is",
"not",
"None",
":",
"selection",
"=",
"PlaySelection",
"(",
"event",
"=",
"event",
",",
"play",
"=",
"event",
".",
"play",
")",
"selection",
".",
"save",
"(",
")"
] |
Copying data from the old `Event.movie` and `Event.play` ForeignKey fields
into the new `Event.movies` and `Event.plays` ManyToManyFields.
|
[
"Copying",
"data",
"from",
"the",
"old",
"Event",
".",
"movie",
"and",
"Event",
".",
"play",
"ForeignKey",
"fields",
"into",
"the",
"new",
"Event",
".",
"movies",
"and",
"Event",
".",
"plays",
"ManyToManyFields",
"."
] |
f3c72004f9caa1fde0f5a3b2f0d2bf285fc01ada
|
https://github.com/philgyford/django-spectator/blob/f3c72004f9caa1fde0f5a3b2f0d2bf285fc01ada/spectator/events/migrations/0017_copy_movies_and_plays_data.py#L6-L23
|
train
|
philgyford/django-spectator
|
spectator/events/migrations/0006_event_slug_20180102_1127.py
|
set_slug
|
def set_slug(apps, schema_editor):
"""
Create a slug for each Event already in the DB.
"""
Event = apps.get_model('spectator_events', 'Event')
for e in Event.objects.all():
e.slug = generate_slug(e.pk)
e.save(update_fields=['slug'])
|
python
|
def set_slug(apps, schema_editor):
"""
Create a slug for each Event already in the DB.
"""
Event = apps.get_model('spectator_events', 'Event')
for e in Event.objects.all():
e.slug = generate_slug(e.pk)
e.save(update_fields=['slug'])
|
[
"def",
"set_slug",
"(",
"apps",
",",
"schema_editor",
")",
":",
"Event",
"=",
"apps",
".",
"get_model",
"(",
"'spectator_events'",
",",
"'Event'",
")",
"for",
"e",
"in",
"Event",
".",
"objects",
".",
"all",
"(",
")",
":",
"e",
".",
"slug",
"=",
"generate_slug",
"(",
"e",
".",
"pk",
")",
"e",
".",
"save",
"(",
"update_fields",
"=",
"[",
"'slug'",
"]",
")"
] |
Create a slug for each Event already in the DB.
|
[
"Create",
"a",
"slug",
"for",
"each",
"Event",
"already",
"in",
"the",
"DB",
"."
] |
f3c72004f9caa1fde0f5a3b2f0d2bf285fc01ada
|
https://github.com/philgyford/django-spectator/blob/f3c72004f9caa1fde0f5a3b2f0d2bf285fc01ada/spectator/events/migrations/0006_event_slug_20180102_1127.py#L24-L32
|
train
|
philgyford/django-spectator
|
spectator/core/paginator.py
|
DiggPaginator.page
|
def page(self, number, *args, **kwargs):
"""Return a standard ``Page`` instance with custom, digg-specific
page ranges attached.
"""
page = super().page(number, *args, **kwargs)
number = int(number) # we know this will work
# easier access
num_pages, body, tail, padding, margin = \
self.num_pages, self.body, self.tail, self.padding, self.margin
# put active page in middle of main range
main_range = list(map(int, [
math.floor(number-body/2.0)+1, # +1 = shift odd body to right
math.floor(number+body/2.0)]))
# adjust bounds
if main_range[0] < 1:
main_range = list(map(abs(main_range[0]-1).__add__, main_range))
if main_range[1] > num_pages:
main_range = list(map((num_pages-main_range[1]).__add__, main_range))
# Determine leading and trailing ranges; if possible and appropriate,
# combine them with the main range, in which case the resulting main
# block might end up considerable larger than requested. While we
# can't guarantee the exact size in those cases, we can at least try
# to come as close as possible: we can reduce the other boundary to
# max padding, instead of using half the body size, which would
# otherwise be the case. If the padding is large enough, this will
# of course have no effect.
# Example:
# total pages=100, page=4, body=5, (default padding=2)
# 1 2 3 [4] 5 6 ... 99 100
# total pages=100, page=4, body=5, padding=1
# 1 2 3 [4] 5 ... 99 100
# If it were not for this adjustment, both cases would result in the
# first output, regardless of the padding value.
if main_range[0] <= tail+margin:
leading = []
main_range = [1, max(body, min(number+padding, main_range[1]))]
main_range[0] = 1
else:
leading = list(range(1, tail+1))
# basically same for trailing range, but not in ``left_align`` mode
if self.align_left:
trailing = []
else:
if main_range[1] >= num_pages-(tail+margin)+1:
trailing = []
if not leading:
# ... but handle the special case of neither leading nor
# trailing ranges; otherwise, we would now modify the
# main range low bound, which we just set in the previous
# section, again.
main_range = [1, num_pages]
else:
main_range = [min(num_pages-body+1, max(number-padding, main_range[0])), num_pages]
else:
trailing = list(range(num_pages-tail+1, num_pages+1))
# finally, normalize values that are out of bound; this basically
# fixes all the things the above code screwed up in the simple case
# of few enough pages where one range would suffice.
main_range = [max(main_range[0], 1), min(main_range[1], num_pages)]
# make the result of our calculations available as custom ranges
# on the ``Page`` instance.
page.main_range = list(range(main_range[0], main_range[1]+1))
page.leading_range = leading
page.trailing_range = trailing
page.page_range = reduce(lambda x, y: x+((x and y) and [False])+y,
[page.leading_range, page.main_range, page.trailing_range])
page.__class__ = DiggPage
return page
|
python
|
def page(self, number, *args, **kwargs):
"""Return a standard ``Page`` instance with custom, digg-specific
page ranges attached.
"""
page = super().page(number, *args, **kwargs)
number = int(number) # we know this will work
# easier access
num_pages, body, tail, padding, margin = \
self.num_pages, self.body, self.tail, self.padding, self.margin
# put active page in middle of main range
main_range = list(map(int, [
math.floor(number-body/2.0)+1, # +1 = shift odd body to right
math.floor(number+body/2.0)]))
# adjust bounds
if main_range[0] < 1:
main_range = list(map(abs(main_range[0]-1).__add__, main_range))
if main_range[1] > num_pages:
main_range = list(map((num_pages-main_range[1]).__add__, main_range))
# Determine leading and trailing ranges; if possible and appropriate,
# combine them with the main range, in which case the resulting main
# block might end up considerable larger than requested. While we
# can't guarantee the exact size in those cases, we can at least try
# to come as close as possible: we can reduce the other boundary to
# max padding, instead of using half the body size, which would
# otherwise be the case. If the padding is large enough, this will
# of course have no effect.
# Example:
# total pages=100, page=4, body=5, (default padding=2)
# 1 2 3 [4] 5 6 ... 99 100
# total pages=100, page=4, body=5, padding=1
# 1 2 3 [4] 5 ... 99 100
# If it were not for this adjustment, both cases would result in the
# first output, regardless of the padding value.
if main_range[0] <= tail+margin:
leading = []
main_range = [1, max(body, min(number+padding, main_range[1]))]
main_range[0] = 1
else:
leading = list(range(1, tail+1))
# basically same for trailing range, but not in ``left_align`` mode
if self.align_left:
trailing = []
else:
if main_range[1] >= num_pages-(tail+margin)+1:
trailing = []
if not leading:
# ... but handle the special case of neither leading nor
# trailing ranges; otherwise, we would now modify the
# main range low bound, which we just set in the previous
# section, again.
main_range = [1, num_pages]
else:
main_range = [min(num_pages-body+1, max(number-padding, main_range[0])), num_pages]
else:
trailing = list(range(num_pages-tail+1, num_pages+1))
# finally, normalize values that are out of bound; this basically
# fixes all the things the above code screwed up in the simple case
# of few enough pages where one range would suffice.
main_range = [max(main_range[0], 1), min(main_range[1], num_pages)]
# make the result of our calculations available as custom ranges
# on the ``Page`` instance.
page.main_range = list(range(main_range[0], main_range[1]+1))
page.leading_range = leading
page.trailing_range = trailing
page.page_range = reduce(lambda x, y: x+((x and y) and [False])+y,
[page.leading_range, page.main_range, page.trailing_range])
page.__class__ = DiggPage
return page
|
[
"def",
"page",
"(",
"self",
",",
"number",
",",
"*",
"args",
",",
"*",
"*",
"kwargs",
")",
":",
"page",
"=",
"super",
"(",
")",
".",
"page",
"(",
"number",
",",
"*",
"args",
",",
"*",
"*",
"kwargs",
")",
"number",
"=",
"int",
"(",
"number",
")",
"# we know this will work",
"# easier access",
"num_pages",
",",
"body",
",",
"tail",
",",
"padding",
",",
"margin",
"=",
"self",
".",
"num_pages",
",",
"self",
".",
"body",
",",
"self",
".",
"tail",
",",
"self",
".",
"padding",
",",
"self",
".",
"margin",
"# put active page in middle of main range",
"main_range",
"=",
"list",
"(",
"map",
"(",
"int",
",",
"[",
"math",
".",
"floor",
"(",
"number",
"-",
"body",
"/",
"2.0",
")",
"+",
"1",
",",
"# +1 = shift odd body to right",
"math",
".",
"floor",
"(",
"number",
"+",
"body",
"/",
"2.0",
")",
"]",
")",
")",
"# adjust bounds",
"if",
"main_range",
"[",
"0",
"]",
"<",
"1",
":",
"main_range",
"=",
"list",
"(",
"map",
"(",
"abs",
"(",
"main_range",
"[",
"0",
"]",
"-",
"1",
")",
".",
"__add__",
",",
"main_range",
")",
")",
"if",
"main_range",
"[",
"1",
"]",
">",
"num_pages",
":",
"main_range",
"=",
"list",
"(",
"map",
"(",
"(",
"num_pages",
"-",
"main_range",
"[",
"1",
"]",
")",
".",
"__add__",
",",
"main_range",
")",
")",
"# Determine leading and trailing ranges; if possible and appropriate,",
"# combine them with the main range, in which case the resulting main",
"# block might end up considerable larger than requested. While we",
"# can't guarantee the exact size in those cases, we can at least try",
"# to come as close as possible: we can reduce the other boundary to",
"# max padding, instead of using half the body size, which would",
"# otherwise be the case. If the padding is large enough, this will",
"# of course have no effect.",
"# Example:",
"# total pages=100, page=4, body=5, (default padding=2)",
"# 1 2 3 [4] 5 6 ... 99 100",
"# total pages=100, page=4, body=5, padding=1",
"# 1 2 3 [4] 5 ... 99 100",
"# If it were not for this adjustment, both cases would result in the",
"# first output, regardless of the padding value.",
"if",
"main_range",
"[",
"0",
"]",
"<=",
"tail",
"+",
"margin",
":",
"leading",
"=",
"[",
"]",
"main_range",
"=",
"[",
"1",
",",
"max",
"(",
"body",
",",
"min",
"(",
"number",
"+",
"padding",
",",
"main_range",
"[",
"1",
"]",
")",
")",
"]",
"main_range",
"[",
"0",
"]",
"=",
"1",
"else",
":",
"leading",
"=",
"list",
"(",
"range",
"(",
"1",
",",
"tail",
"+",
"1",
")",
")",
"# basically same for trailing range, but not in ``left_align`` mode",
"if",
"self",
".",
"align_left",
":",
"trailing",
"=",
"[",
"]",
"else",
":",
"if",
"main_range",
"[",
"1",
"]",
">=",
"num_pages",
"-",
"(",
"tail",
"+",
"margin",
")",
"+",
"1",
":",
"trailing",
"=",
"[",
"]",
"if",
"not",
"leading",
":",
"# ... but handle the special case of neither leading nor",
"# trailing ranges; otherwise, we would now modify the",
"# main range low bound, which we just set in the previous",
"# section, again.",
"main_range",
"=",
"[",
"1",
",",
"num_pages",
"]",
"else",
":",
"main_range",
"=",
"[",
"min",
"(",
"num_pages",
"-",
"body",
"+",
"1",
",",
"max",
"(",
"number",
"-",
"padding",
",",
"main_range",
"[",
"0",
"]",
")",
")",
",",
"num_pages",
"]",
"else",
":",
"trailing",
"=",
"list",
"(",
"range",
"(",
"num_pages",
"-",
"tail",
"+",
"1",
",",
"num_pages",
"+",
"1",
")",
")",
"# finally, normalize values that are out of bound; this basically",
"# fixes all the things the above code screwed up in the simple case",
"# of few enough pages where one range would suffice.",
"main_range",
"=",
"[",
"max",
"(",
"main_range",
"[",
"0",
"]",
",",
"1",
")",
",",
"min",
"(",
"main_range",
"[",
"1",
"]",
",",
"num_pages",
")",
"]",
"# make the result of our calculations available as custom ranges",
"# on the ``Page`` instance.",
"page",
".",
"main_range",
"=",
"list",
"(",
"range",
"(",
"main_range",
"[",
"0",
"]",
",",
"main_range",
"[",
"1",
"]",
"+",
"1",
")",
")",
"page",
".",
"leading_range",
"=",
"leading",
"page",
".",
"trailing_range",
"=",
"trailing",
"page",
".",
"page_range",
"=",
"reduce",
"(",
"lambda",
"x",
",",
"y",
":",
"x",
"+",
"(",
"(",
"x",
"and",
"y",
")",
"and",
"[",
"False",
"]",
")",
"+",
"y",
",",
"[",
"page",
".",
"leading_range",
",",
"page",
".",
"main_range",
",",
"page",
".",
"trailing_range",
"]",
")",
"page",
".",
"__class__",
"=",
"DiggPage",
"return",
"page"
] |
Return a standard ``Page`` instance with custom, digg-specific
page ranges attached.
|
[
"Return",
"a",
"standard",
"Page",
"instance",
"with",
"custom",
"digg",
"-",
"specific",
"page",
"ranges",
"attached",
"."
] |
f3c72004f9caa1fde0f5a3b2f0d2bf285fc01ada
|
https://github.com/philgyford/django-spectator/blob/f3c72004f9caa1fde0f5a3b2f0d2bf285fc01ada/spectator/core/paginator.py#L195-L269
|
train
|
ccpem/mrcfile
|
setup.py
|
version
|
def version():
"""Get the version number without importing the mrcfile package."""
namespace = {}
with open(os.path.join('mrcfile', 'version.py')) as f:
exec(f.read(), namespace)
return namespace['__version__']
|
python
|
def version():
"""Get the version number without importing the mrcfile package."""
namespace = {}
with open(os.path.join('mrcfile', 'version.py')) as f:
exec(f.read(), namespace)
return namespace['__version__']
|
[
"def",
"version",
"(",
")",
":",
"namespace",
"=",
"{",
"}",
"with",
"open",
"(",
"os",
".",
"path",
".",
"join",
"(",
"'mrcfile'",
",",
"'version.py'",
")",
")",
"as",
"f",
":",
"exec",
"(",
"f",
".",
"read",
"(",
")",
",",
"namespace",
")",
"return",
"namespace",
"[",
"'__version__'",
"]"
] |
Get the version number without importing the mrcfile package.
|
[
"Get",
"the",
"version",
"number",
"without",
"importing",
"the",
"mrcfile",
"package",
"."
] |
96b862ad29884f5a5082a69e2aba8b0829090838
|
https://github.com/ccpem/mrcfile/blob/96b862ad29884f5a5082a69e2aba8b0829090838/setup.py#L9-L14
|
train
|
philgyford/django-spectator
|
spectator/events/views.py
|
EventListView.get_event_counts
|
def get_event_counts(self):
"""
Returns a dict like:
{'counts': {
'all': 30,
'movie': 12,
'gig': 10,
}}
"""
counts = {'all': Event.objects.count(),}
for k,v in Event.KIND_CHOICES:
# e.g. 'movie_count':
counts[k] = Event.objects.filter(kind=k).count()
return {'counts': counts,}
|
python
|
def get_event_counts(self):
"""
Returns a dict like:
{'counts': {
'all': 30,
'movie': 12,
'gig': 10,
}}
"""
counts = {'all': Event.objects.count(),}
for k,v in Event.KIND_CHOICES:
# e.g. 'movie_count':
counts[k] = Event.objects.filter(kind=k).count()
return {'counts': counts,}
|
[
"def",
"get_event_counts",
"(",
"self",
")",
":",
"counts",
"=",
"{",
"'all'",
":",
"Event",
".",
"objects",
".",
"count",
"(",
")",
",",
"}",
"for",
"k",
",",
"v",
"in",
"Event",
".",
"KIND_CHOICES",
":",
"# e.g. 'movie_count':",
"counts",
"[",
"k",
"]",
"=",
"Event",
".",
"objects",
".",
"filter",
"(",
"kind",
"=",
"k",
")",
".",
"count",
"(",
")",
"return",
"{",
"'counts'",
":",
"counts",
",",
"}"
] |
Returns a dict like:
{'counts': {
'all': 30,
'movie': 12,
'gig': 10,
}}
|
[
"Returns",
"a",
"dict",
"like",
":",
"{",
"counts",
":",
"{",
"all",
":",
"30",
"movie",
":",
"12",
"gig",
":",
"10",
"}}"
] |
f3c72004f9caa1fde0f5a3b2f0d2bf285fc01ada
|
https://github.com/philgyford/django-spectator/blob/f3c72004f9caa1fde0f5a3b2f0d2bf285fc01ada/spectator/events/views.py#L52-L67
|
train
|
philgyford/django-spectator
|
spectator/events/views.py
|
EventListView.get_event_kind
|
def get_event_kind(self):
"""
Unless we're on the front page we'll have a kind_slug like 'movies'.
We need to translate that into an event `kind` like 'movie'.
"""
slug = self.kwargs.get('kind_slug', None)
if slug is None:
return None # Front page; showing all Event kinds.
else:
slugs_to_kinds = {v:k for k,v in Event.KIND_SLUGS.items()}
return slugs_to_kinds.get(slug, None)
|
python
|
def get_event_kind(self):
"""
Unless we're on the front page we'll have a kind_slug like 'movies'.
We need to translate that into an event `kind` like 'movie'.
"""
slug = self.kwargs.get('kind_slug', None)
if slug is None:
return None # Front page; showing all Event kinds.
else:
slugs_to_kinds = {v:k for k,v in Event.KIND_SLUGS.items()}
return slugs_to_kinds.get(slug, None)
|
[
"def",
"get_event_kind",
"(",
"self",
")",
":",
"slug",
"=",
"self",
".",
"kwargs",
".",
"get",
"(",
"'kind_slug'",
",",
"None",
")",
"if",
"slug",
"is",
"None",
":",
"return",
"None",
"# Front page; showing all Event kinds.",
"else",
":",
"slugs_to_kinds",
"=",
"{",
"v",
":",
"k",
"for",
"k",
",",
"v",
"in",
"Event",
".",
"KIND_SLUGS",
".",
"items",
"(",
")",
"}",
"return",
"slugs_to_kinds",
".",
"get",
"(",
"slug",
",",
"None",
")"
] |
Unless we're on the front page we'll have a kind_slug like 'movies'.
We need to translate that into an event `kind` like 'movie'.
|
[
"Unless",
"we",
"re",
"on",
"the",
"front",
"page",
"we",
"ll",
"have",
"a",
"kind_slug",
"like",
"movies",
".",
"We",
"need",
"to",
"translate",
"that",
"into",
"an",
"event",
"kind",
"like",
"movie",
"."
] |
f3c72004f9caa1fde0f5a3b2f0d2bf285fc01ada
|
https://github.com/philgyford/django-spectator/blob/f3c72004f9caa1fde0f5a3b2f0d2bf285fc01ada/spectator/events/views.py#L69-L79
|
train
|
philgyford/django-spectator
|
spectator/events/views.py
|
EventListView.get_queryset
|
def get_queryset(self):
"Restrict to a single kind of event, if any, and include Venue data."
qs = super().get_queryset()
kind = self.get_event_kind()
if kind is not None:
qs = qs.filter(kind=kind)
qs = qs.select_related('venue')
return qs
|
python
|
def get_queryset(self):
"Restrict to a single kind of event, if any, and include Venue data."
qs = super().get_queryset()
kind = self.get_event_kind()
if kind is not None:
qs = qs.filter(kind=kind)
qs = qs.select_related('venue')
return qs
|
[
"def",
"get_queryset",
"(",
"self",
")",
":",
"qs",
"=",
"super",
"(",
")",
".",
"get_queryset",
"(",
")",
"kind",
"=",
"self",
".",
"get_event_kind",
"(",
")",
"if",
"kind",
"is",
"not",
"None",
":",
"qs",
"=",
"qs",
".",
"filter",
"(",
"kind",
"=",
"kind",
")",
"qs",
"=",
"qs",
".",
"select_related",
"(",
"'venue'",
")",
"return",
"qs"
] |
Restrict to a single kind of event, if any, and include Venue data.
|
[
"Restrict",
"to",
"a",
"single",
"kind",
"of",
"event",
"if",
"any",
"and",
"include",
"Venue",
"data",
"."
] |
f3c72004f9caa1fde0f5a3b2f0d2bf285fc01ada
|
https://github.com/philgyford/django-spectator/blob/f3c72004f9caa1fde0f5a3b2f0d2bf285fc01ada/spectator/events/views.py#L81-L91
|
train
|
philgyford/django-spectator
|
spectator/events/views.py
|
WorkMixin.get_work_kind
|
def get_work_kind(self):
"""
We'll have a kind_slug like 'movies'.
We need to translate that into a work `kind` like 'movie'.
"""
slugs_to_kinds = {v:k for k,v in Work.KIND_SLUGS.items()}
return slugs_to_kinds.get(self.kind_slug, None)
|
python
|
def get_work_kind(self):
"""
We'll have a kind_slug like 'movies'.
We need to translate that into a work `kind` like 'movie'.
"""
slugs_to_kinds = {v:k for k,v in Work.KIND_SLUGS.items()}
return slugs_to_kinds.get(self.kind_slug, None)
|
[
"def",
"get_work_kind",
"(",
"self",
")",
":",
"slugs_to_kinds",
"=",
"{",
"v",
":",
"k",
"for",
"k",
",",
"v",
"in",
"Work",
".",
"KIND_SLUGS",
".",
"items",
"(",
")",
"}",
"return",
"slugs_to_kinds",
".",
"get",
"(",
"self",
".",
"kind_slug",
",",
"None",
")"
] |
We'll have a kind_slug like 'movies'.
We need to translate that into a work `kind` like 'movie'.
|
[
"We",
"ll",
"have",
"a",
"kind_slug",
"like",
"movies",
".",
"We",
"need",
"to",
"translate",
"that",
"into",
"a",
"work",
"kind",
"like",
"movie",
"."
] |
f3c72004f9caa1fde0f5a3b2f0d2bf285fc01ada
|
https://github.com/philgyford/django-spectator/blob/f3c72004f9caa1fde0f5a3b2f0d2bf285fc01ada/spectator/events/views.py#L147-L153
|
train
|
philgyford/django-spectator
|
spectator/events/views.py
|
VenueListView.get_countries
|
def get_countries(self):
"""
Returns a list of dicts, one per country that has at least one Venue
in it.
Each dict has 'code' and 'name' elements.
The list is sorted by the country 'name's.
"""
qs = Venue.objects.values('country') \
.exclude(country='') \
.distinct() \
.order_by('country')
countries = []
for c in qs:
countries.append({
'code': c['country'],
'name': Venue.get_country_name(c['country'])
})
return sorted(countries, key=lambda k: k['name'])
|
python
|
def get_countries(self):
"""
Returns a list of dicts, one per country that has at least one Venue
in it.
Each dict has 'code' and 'name' elements.
The list is sorted by the country 'name's.
"""
qs = Venue.objects.values('country') \
.exclude(country='') \
.distinct() \
.order_by('country')
countries = []
for c in qs:
countries.append({
'code': c['country'],
'name': Venue.get_country_name(c['country'])
})
return sorted(countries, key=lambda k: k['name'])
|
[
"def",
"get_countries",
"(",
"self",
")",
":",
"qs",
"=",
"Venue",
".",
"objects",
".",
"values",
"(",
"'country'",
")",
".",
"exclude",
"(",
"country",
"=",
"''",
")",
".",
"distinct",
"(",
")",
".",
"order_by",
"(",
"'country'",
")",
"countries",
"=",
"[",
"]",
"for",
"c",
"in",
"qs",
":",
"countries",
".",
"append",
"(",
"{",
"'code'",
":",
"c",
"[",
"'country'",
"]",
",",
"'name'",
":",
"Venue",
".",
"get_country_name",
"(",
"c",
"[",
"'country'",
"]",
")",
"}",
")",
"return",
"sorted",
"(",
"countries",
",",
"key",
"=",
"lambda",
"k",
":",
"k",
"[",
"'name'",
"]",
")"
] |
Returns a list of dicts, one per country that has at least one Venue
in it.
Each dict has 'code' and 'name' elements.
The list is sorted by the country 'name's.
|
[
"Returns",
"a",
"list",
"of",
"dicts",
"one",
"per",
"country",
"that",
"has",
"at",
"least",
"one",
"Venue",
"in",
"it",
"."
] |
f3c72004f9caa1fde0f5a3b2f0d2bf285fc01ada
|
https://github.com/philgyford/django-spectator/blob/f3c72004f9caa1fde0f5a3b2f0d2bf285fc01ada/spectator/events/views.py#L216-L237
|
train
|
philgyford/django-spectator
|
spectator/events/migrations/0032_recreate_work_slugs.py
|
forwards
|
def forwards(apps, schema_editor):
"""
Re-save all the Works because something earlier didn't create their slugs.
"""
Work = apps.get_model('spectator_events', 'Work')
for work in Work.objects.all():
if not work.slug:
work.slug = generate_slug(work.pk)
work.save()
|
python
|
def forwards(apps, schema_editor):
"""
Re-save all the Works because something earlier didn't create their slugs.
"""
Work = apps.get_model('spectator_events', 'Work')
for work in Work.objects.all():
if not work.slug:
work.slug = generate_slug(work.pk)
work.save()
|
[
"def",
"forwards",
"(",
"apps",
",",
"schema_editor",
")",
":",
"Work",
"=",
"apps",
".",
"get_model",
"(",
"'spectator_events'",
",",
"'Work'",
")",
"for",
"work",
"in",
"Work",
".",
"objects",
".",
"all",
"(",
")",
":",
"if",
"not",
"work",
".",
"slug",
":",
"work",
".",
"slug",
"=",
"generate_slug",
"(",
"work",
".",
"pk",
")",
"work",
".",
"save",
"(",
")"
] |
Re-save all the Works because something earlier didn't create their slugs.
|
[
"Re",
"-",
"save",
"all",
"the",
"Works",
"because",
"something",
"earlier",
"didn",
"t",
"create",
"their",
"slugs",
"."
] |
f3c72004f9caa1fde0f5a3b2f0d2bf285fc01ada
|
https://github.com/philgyford/django-spectator/blob/f3c72004f9caa1fde0f5a3b2f0d2bf285fc01ada/spectator/events/migrations/0032_recreate_work_slugs.py#L30-L39
|
train
|
philgyford/django-spectator
|
spectator/events/templatetags/spectator_events.py
|
annual_event_counts
|
def annual_event_counts(kind='all'):
"""
Returns a QuerySet of dicts, each one with these keys:
* year - a date object representing the year
* total - the number of events of `kind` that year
kind - The Event `kind`, or 'all' for all kinds (default).
"""
qs = Event.objects
if kind != 'all':
qs = qs.filter(kind=kind)
qs = qs.annotate(year=TruncYear('date')) \
.values('year') \
.annotate(total=Count('id')) \
.order_by('year')
return qs
|
python
|
def annual_event_counts(kind='all'):
"""
Returns a QuerySet of dicts, each one with these keys:
* year - a date object representing the year
* total - the number of events of `kind` that year
kind - The Event `kind`, or 'all' for all kinds (default).
"""
qs = Event.objects
if kind != 'all':
qs = qs.filter(kind=kind)
qs = qs.annotate(year=TruncYear('date')) \
.values('year') \
.annotate(total=Count('id')) \
.order_by('year')
return qs
|
[
"def",
"annual_event_counts",
"(",
"kind",
"=",
"'all'",
")",
":",
"qs",
"=",
"Event",
".",
"objects",
"if",
"kind",
"!=",
"'all'",
":",
"qs",
"=",
"qs",
".",
"filter",
"(",
"kind",
"=",
"kind",
")",
"qs",
"=",
"qs",
".",
"annotate",
"(",
"year",
"=",
"TruncYear",
"(",
"'date'",
")",
")",
".",
"values",
"(",
"'year'",
")",
".",
"annotate",
"(",
"total",
"=",
"Count",
"(",
"'id'",
")",
")",
".",
"order_by",
"(",
"'year'",
")",
"return",
"qs"
] |
Returns a QuerySet of dicts, each one with these keys:
* year - a date object representing the year
* total - the number of events of `kind` that year
kind - The Event `kind`, or 'all' for all kinds (default).
|
[
"Returns",
"a",
"QuerySet",
"of",
"dicts",
"each",
"one",
"with",
"these",
"keys",
":"
] |
f3c72004f9caa1fde0f5a3b2f0d2bf285fc01ada
|
https://github.com/philgyford/django-spectator/blob/f3c72004f9caa1fde0f5a3b2f0d2bf285fc01ada/spectator/events/templatetags/spectator_events.py#L17-L36
|
train
|
philgyford/django-spectator
|
spectator/events/templatetags/spectator_events.py
|
annual_event_counts_card
|
def annual_event_counts_card(kind='all', current_year=None):
"""
Displays years and the number of events per year.
kind is an Event kind (like 'cinema', 'gig', etc.) or 'all' (default).
current_year is an optional date object representing the year we're already
showing information about.
"""
if kind == 'all':
card_title = 'Events per year'
else:
card_title = '{} per year'.format(Event.get_kind_name_plural(kind))
return {
'card_title': card_title,
'kind': kind,
'years': annual_event_counts(kind=kind),
'current_year': current_year
}
|
python
|
def annual_event_counts_card(kind='all', current_year=None):
"""
Displays years and the number of events per year.
kind is an Event kind (like 'cinema', 'gig', etc.) or 'all' (default).
current_year is an optional date object representing the year we're already
showing information about.
"""
if kind == 'all':
card_title = 'Events per year'
else:
card_title = '{} per year'.format(Event.get_kind_name_plural(kind))
return {
'card_title': card_title,
'kind': kind,
'years': annual_event_counts(kind=kind),
'current_year': current_year
}
|
[
"def",
"annual_event_counts_card",
"(",
"kind",
"=",
"'all'",
",",
"current_year",
"=",
"None",
")",
":",
"if",
"kind",
"==",
"'all'",
":",
"card_title",
"=",
"'Events per year'",
"else",
":",
"card_title",
"=",
"'{} per year'",
".",
"format",
"(",
"Event",
".",
"get_kind_name_plural",
"(",
"kind",
")",
")",
"return",
"{",
"'card_title'",
":",
"card_title",
",",
"'kind'",
":",
"kind",
",",
"'years'",
":",
"annual_event_counts",
"(",
"kind",
"=",
"kind",
")",
",",
"'current_year'",
":",
"current_year",
"}"
] |
Displays years and the number of events per year.
kind is an Event kind (like 'cinema', 'gig', etc.) or 'all' (default).
current_year is an optional date object representing the year we're already
showing information about.
|
[
"Displays",
"years",
"and",
"the",
"number",
"of",
"events",
"per",
"year",
"."
] |
f3c72004f9caa1fde0f5a3b2f0d2bf285fc01ada
|
https://github.com/philgyford/django-spectator/blob/f3c72004f9caa1fde0f5a3b2f0d2bf285fc01ada/spectator/events/templatetags/spectator_events.py#L40-L58
|
train
|
philgyford/django-spectator
|
spectator/events/templatetags/spectator_events.py
|
display_date
|
def display_date(d):
"""
Render a date/datetime (d) as a date, using the SPECTATOR_DATE_FORMAT
setting. Wrap the output in a <time> tag.
Time tags: http://www.brucelawson.co.uk/2012/best-of-time/
"""
stamp = d.strftime('%Y-%m-%d')
visible_date = d.strftime(app_settings.DATE_FORMAT)
return format_html('<time datetime="%(stamp)s">%(visible)s</time>' % {
'stamp': stamp,
'visible': visible_date
})
|
python
|
def display_date(d):
"""
Render a date/datetime (d) as a date, using the SPECTATOR_DATE_FORMAT
setting. Wrap the output in a <time> tag.
Time tags: http://www.brucelawson.co.uk/2012/best-of-time/
"""
stamp = d.strftime('%Y-%m-%d')
visible_date = d.strftime(app_settings.DATE_FORMAT)
return format_html('<time datetime="%(stamp)s">%(visible)s</time>' % {
'stamp': stamp,
'visible': visible_date
})
|
[
"def",
"display_date",
"(",
"d",
")",
":",
"stamp",
"=",
"d",
".",
"strftime",
"(",
"'%Y-%m-%d'",
")",
"visible_date",
"=",
"d",
".",
"strftime",
"(",
"app_settings",
".",
"DATE_FORMAT",
")",
"return",
"format_html",
"(",
"'<time datetime=\"%(stamp)s\">%(visible)s</time>'",
"%",
"{",
"'stamp'",
":",
"stamp",
",",
"'visible'",
":",
"visible_date",
"}",
")"
] |
Render a date/datetime (d) as a date, using the SPECTATOR_DATE_FORMAT
setting. Wrap the output in a <time> tag.
Time tags: http://www.brucelawson.co.uk/2012/best-of-time/
|
[
"Render",
"a",
"date",
"/",
"datetime",
"(",
"d",
")",
"as",
"a",
"date",
"using",
"the",
"SPECTATOR_DATE_FORMAT",
"setting",
".",
"Wrap",
"the",
"output",
"in",
"a",
"<time",
">",
"tag",
"."
] |
f3c72004f9caa1fde0f5a3b2f0d2bf285fc01ada
|
https://github.com/philgyford/django-spectator/blob/f3c72004f9caa1fde0f5a3b2f0d2bf285fc01ada/spectator/events/templatetags/spectator_events.py#L62-L75
|
train
|
philgyford/django-spectator
|
spectator/events/templatetags/spectator_events.py
|
event_list_tabs
|
def event_list_tabs(counts, current_kind, page_number=1):
"""
Displays the tabs to different event_list pages.
`counts` is a dict of number of events for each kind, like:
{'all': 30, 'gig': 12, 'movie': 18,}
`current_kind` is the event kind that's active, if any. e.g. 'gig',
'movie', etc.
`page_number` is the current page of this kind of events we're on.
"""
return {
'counts': counts,
'current_kind': current_kind,
'page_number': page_number,
# A list of all the kinds we might show tabs for, like
# ['gig', 'movie', 'play', ...]
'event_kinds': Event.get_kinds(),
# A dict of data about each kind, keyed by kind ('gig') including
# data about 'name', 'name_plural' and 'slug':
'event_kinds_data': Event.get_kinds_data(),
}
|
python
|
def event_list_tabs(counts, current_kind, page_number=1):
"""
Displays the tabs to different event_list pages.
`counts` is a dict of number of events for each kind, like:
{'all': 30, 'gig': 12, 'movie': 18,}
`current_kind` is the event kind that's active, if any. e.g. 'gig',
'movie', etc.
`page_number` is the current page of this kind of events we're on.
"""
return {
'counts': counts,
'current_kind': current_kind,
'page_number': page_number,
# A list of all the kinds we might show tabs for, like
# ['gig', 'movie', 'play', ...]
'event_kinds': Event.get_kinds(),
# A dict of data about each kind, keyed by kind ('gig') including
# data about 'name', 'name_plural' and 'slug':
'event_kinds_data': Event.get_kinds_data(),
}
|
[
"def",
"event_list_tabs",
"(",
"counts",
",",
"current_kind",
",",
"page_number",
"=",
"1",
")",
":",
"return",
"{",
"'counts'",
":",
"counts",
",",
"'current_kind'",
":",
"current_kind",
",",
"'page_number'",
":",
"page_number",
",",
"# A list of all the kinds we might show tabs for, like",
"# ['gig', 'movie', 'play', ...]",
"'event_kinds'",
":",
"Event",
".",
"get_kinds",
"(",
")",
",",
"# A dict of data about each kind, keyed by kind ('gig') including",
"# data about 'name', 'name_plural' and 'slug':",
"'event_kinds_data'",
":",
"Event",
".",
"get_kinds_data",
"(",
")",
",",
"}"
] |
Displays the tabs to different event_list pages.
`counts` is a dict of number of events for each kind, like:
{'all': 30, 'gig': 12, 'movie': 18,}
`current_kind` is the event kind that's active, if any. e.g. 'gig',
'movie', etc.
`page_number` is the current page of this kind of events we're on.
|
[
"Displays",
"the",
"tabs",
"to",
"different",
"event_list",
"pages",
"."
] |
f3c72004f9caa1fde0f5a3b2f0d2bf285fc01ada
|
https://github.com/philgyford/django-spectator/blob/f3c72004f9caa1fde0f5a3b2f0d2bf285fc01ada/spectator/events/templatetags/spectator_events.py#L79-L101
|
train
|
philgyford/django-spectator
|
spectator/events/templatetags/spectator_events.py
|
day_events_card
|
def day_events_card(date):
"""
Displays Events that happened on the supplied date.
`date` is a date object.
"""
d = date.strftime(app_settings.DATE_FORMAT)
card_title = 'Events on {}'.format(d)
return {
'card_title': card_title,
'event_list': day_events(date=date),
}
|
python
|
def day_events_card(date):
"""
Displays Events that happened on the supplied date.
`date` is a date object.
"""
d = date.strftime(app_settings.DATE_FORMAT)
card_title = 'Events on {}'.format(d)
return {
'card_title': card_title,
'event_list': day_events(date=date),
}
|
[
"def",
"day_events_card",
"(",
"date",
")",
":",
"d",
"=",
"date",
".",
"strftime",
"(",
"app_settings",
".",
"DATE_FORMAT",
")",
"card_title",
"=",
"'Events on {}'",
".",
"format",
"(",
"d",
")",
"return",
"{",
"'card_title'",
":",
"card_title",
",",
"'event_list'",
":",
"day_events",
"(",
"date",
"=",
"date",
")",
",",
"}"
] |
Displays Events that happened on the supplied date.
`date` is a date object.
|
[
"Displays",
"Events",
"that",
"happened",
"on",
"the",
"supplied",
"date",
".",
"date",
"is",
"a",
"date",
"object",
"."
] |
f3c72004f9caa1fde0f5a3b2f0d2bf285fc01ada
|
https://github.com/philgyford/django-spectator/blob/f3c72004f9caa1fde0f5a3b2f0d2bf285fc01ada/spectator/events/templatetags/spectator_events.py#L134-L144
|
train
|
philgyford/django-spectator
|
spectator/events/templatetags/spectator_events.py
|
most_seen_creators_card
|
def most_seen_creators_card(event_kind=None, num=10):
"""
Displays a card showing the Creators that are associated with the most Events.
"""
object_list = most_seen_creators(event_kind=event_kind, num=num)
object_list = chartify(object_list, 'num_events', cutoff=1)
return {
'card_title': 'Most seen people/groups',
'score_attr': 'num_events',
'object_list': object_list,
}
|
python
|
def most_seen_creators_card(event_kind=None, num=10):
"""
Displays a card showing the Creators that are associated with the most Events.
"""
object_list = most_seen_creators(event_kind=event_kind, num=num)
object_list = chartify(object_list, 'num_events', cutoff=1)
return {
'card_title': 'Most seen people/groups',
'score_attr': 'num_events',
'object_list': object_list,
}
|
[
"def",
"most_seen_creators_card",
"(",
"event_kind",
"=",
"None",
",",
"num",
"=",
"10",
")",
":",
"object_list",
"=",
"most_seen_creators",
"(",
"event_kind",
"=",
"event_kind",
",",
"num",
"=",
"num",
")",
"object_list",
"=",
"chartify",
"(",
"object_list",
",",
"'num_events'",
",",
"cutoff",
"=",
"1",
")",
"return",
"{",
"'card_title'",
":",
"'Most seen people/groups'",
",",
"'score_attr'",
":",
"'num_events'",
",",
"'object_list'",
":",
"object_list",
",",
"}"
] |
Displays a card showing the Creators that are associated with the most Events.
|
[
"Displays",
"a",
"card",
"showing",
"the",
"Creators",
"that",
"are",
"associated",
"with",
"the",
"most",
"Events",
"."
] |
f3c72004f9caa1fde0f5a3b2f0d2bf285fc01ada
|
https://github.com/philgyford/django-spectator/blob/f3c72004f9caa1fde0f5a3b2f0d2bf285fc01ada/spectator/events/templatetags/spectator_events.py#L179-L191
|
train
|
philgyford/django-spectator
|
spectator/events/templatetags/spectator_events.py
|
most_seen_creators_by_works
|
def most_seen_creators_by_works(work_kind=None, role_name=None, num=10):
"""
Returns a QuerySet of the Creators that are associated with the most Works.
"""
return Creator.objects.by_works(kind=work_kind, role_name=role_name)[:num]
|
python
|
def most_seen_creators_by_works(work_kind=None, role_name=None, num=10):
"""
Returns a QuerySet of the Creators that are associated with the most Works.
"""
return Creator.objects.by_works(kind=work_kind, role_name=role_name)[:num]
|
[
"def",
"most_seen_creators_by_works",
"(",
"work_kind",
"=",
"None",
",",
"role_name",
"=",
"None",
",",
"num",
"=",
"10",
")",
":",
"return",
"Creator",
".",
"objects",
".",
"by_works",
"(",
"kind",
"=",
"work_kind",
",",
"role_name",
"=",
"role_name",
")",
"[",
":",
"num",
"]"
] |
Returns a QuerySet of the Creators that are associated with the most Works.
|
[
"Returns",
"a",
"QuerySet",
"of",
"the",
"Creators",
"that",
"are",
"associated",
"with",
"the",
"most",
"Works",
"."
] |
f3c72004f9caa1fde0f5a3b2f0d2bf285fc01ada
|
https://github.com/philgyford/django-spectator/blob/f3c72004f9caa1fde0f5a3b2f0d2bf285fc01ada/spectator/events/templatetags/spectator_events.py#L195-L199
|
train
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.