path
stringlengths 9
117
| type
stringclasses 2
values | project
stringclasses 10
values | commit_hash
stringlengths 40
40
| commit_message
stringlengths 1
137
| ground_truth
stringlengths 0
2.74k
| main_code
stringlengths 102
3.37k
| context
stringlengths 0
14.7k
|
|---|---|---|---|---|---|---|---|
backend.src.svg.top_repos/get_top_repos_svg
|
Modified
|
avgupta456~github-trends
|
ddea0bdefa9da1ded7c0c04d7eb7f6ae58ac517b
|
fix svgs, check mongodb timing
|
<16>:<del>
<17>:<del> if data.top_repos is None:
<18>:<del> raise ValueError("No repository data available")
<19>:<del> data_repos = data.top_repos
<20>:<del>
<21>:<add> for i in range(min(5, len(data))):
<del> for i in range(min(5, len(data_repos))):
<23>:<add> total = data[0].changed
<del> total = data_repos[0].changed
<25>:<add> repo.add(d.text(data[i].repo, insert=(2, 15), class_="lang-name"))
<del> repo.add(d.text(data_repos[i].repo, insert=(2, 15), class_="lang-name"))
<27>:<del> d.text(
<28>:<del> format_number(data_repos[i].changed),
<29>:<del> insert=(215, 33),
<30>:<del> class_="lang-name",
<31>:<del> )
<32>:<add> d.text(format_number(data[i].changed), insert=(215, 33), class_="lang-name")
<36>:<add> for j, lang in enumerate(data[i].langs):
<del> for j, lang in enumerate(data_repos[i].langs):
|
# module: backend.src.svg.top_repos
+ def get_top_repos_svg(data: List[RepoStats]) -> Drawing:
- def get_top_repos_svg(data: Any) -> Drawing:
<0> d = Drawing(size=(300, 285))
<1> d.defs.add(d.style(style))
<2>
<3> d.add(
<4> d.rect(
<5> size=(299, 284),
<6> insert=(0.5, 0.5),
<7> rx=4.5,
<8> stroke="#e4e2e2",
<9> fill="#fffefe",
<10> )
<11> )
<12>
<13> d.add(d.text("Most Contributed Repositories", insert=(25, 35), class_="header"))
<14>
<15> repos = Group(transform="translate(25, 55)")
<16>
<17> if data.top_repos is None:
<18> raise ValueError("No repository data available")
<19> data_repos = data.top_repos
<20>
<21> for i in range(min(5, len(data_repos))):
<22> translate = "translate(0, " + str(40 * i) + ")"
<23> total = data_repos[0].changed
<24> repo = Group(transform=translate)
<25> repo.add(d.text(data_repos[i].repo, insert=(2, 15), class_="lang-name"))
<26> repo.add(
<27> d.text(
<28> format_number(data_repos[i].changed),
<29> insert=(215, 33),
<30> class_="lang-name",
<31> )
<32> )
<33> progress = Drawing(width="205", x="0", y="25")
<34> progress.add(d.rect(size=(205, 8), insert=(0, 0), rx=5, ry=5, fill="#ddd"))
<35> total_percent = 0
<36> for j, lang in enumerate(data_repos[i].langs):
<37> percent, color = 100 * (lang.additions + lang.deletions) / total, lang</s>
|
===========below chunk 0===========
# module: backend.src.svg.top_repos
+ def get_top_repos_svg(data: List[RepoStats]) -> Drawing:
- def get_top_repos_svg(data: Any) -> Drawing:
# offset: 1
box_size, box_insert = (2.05 * percent, 8), (2.05 * total_percent, 0)
progress.add(
d.rect(size=box_size, insert=box_insert, rx=5, ry=5, fill=color)
)
box_left, box_right = j > 0, j < len(data_repos[i].langs) - 1
box_size = 2.05 * percent - (0 if box_left else 5) - (0 if box_right else 5)
box_insert = 2.05 * total_percent + (5 if not box_left else 0)
progress.add(
d.rect(size=(max(box_size, 3), 8), insert=(box_insert, 0), fill=color)
)
total_percent += percent
repo.add(progress)
repos.add(repo)
d.add(repos)
return d
===========unchanged ref 0===========
at: backend.src.svg.top_repos
format_number(num: int) -> str
at: src.models.user.analytics.RepoLanguage
lang: str
color: str
additions: int
deletions: int
at: src.models.user.analytics.RepoStats
repo: str
langs: List[RepoLanguage]
additions: int
deletions: int
added: int
changed: int
at: src.svg.style
style = """
.header {
font: 600 18px 'Segoe UI', Ubuntu, Sans-Serif;
fill: #2f80ed;
animation: fadeInAnimation 0.8s ease-in-out forwards;
}
.lang-name {
font: 400 11px 'Segoe UI', Ubuntu, Sans-Serif;
fill: #333;
}
@keyframes fadeInAnimation {
from {
opacity: 0;
}
to {
opacity: 1;
}
}
"""
at: typing
List = _alias(list, 1, inst=False, name='List')
|
backend.src.db.functions.get/get_user_by_user_id
|
Modified
|
avgupta456~github-trends
|
ddea0bdefa9da1ded7c0c04d7eb7f6ae58ac517b
|
fix svgs, check mongodb timing
|
<0>:<add> start = datetime.now()
<3>:<add> output = UserModel.parse_obj(user)
<del> return UserModel.parse_obj(user)
|
# module: backend.src.db.functions.get
def get_user_by_user_id(user_id: str) -> Optional[UserModel]:
<0> user: Optional[Dict[str, Any]] = await USERS.find_one({"user_id": user_id}) # type: ignore
<1> if user is None:
<2> return None
<3> return UserModel.parse_obj(user)
<4>
|
===========unchanged ref 0===========
at: datetime
datetime()
at: datetime.datetime
__slots__ = date.__slots__ + time.__slots__
now(tz: Optional[_tzinfo]=...) -> _S
__radd__ = __add__
at: src.db.mongodb
USERS = DB.users # type: ignore
at: typing
Dict = _alias(dict, 2, inst=False, name='Dict')
===========changed ref 0===========
# module: backend.src.svg.top_repos
+ def get_top_repos_svg(data: List[RepoStats]) -> Drawing:
- def get_top_repos_svg(data: Any) -> Drawing:
d = Drawing(size=(300, 285))
d.defs.add(d.style(style))
d.add(
d.rect(
size=(299, 284),
insert=(0.5, 0.5),
rx=4.5,
stroke="#e4e2e2",
fill="#fffefe",
)
)
d.add(d.text("Most Contributed Repositories", insert=(25, 35), class_="header"))
repos = Group(transform="translate(25, 55)")
-
- if data.top_repos is None:
- raise ValueError("No repository data available")
- data_repos = data.top_repos
-
+ for i in range(min(5, len(data))):
- for i in range(min(5, len(data_repos))):
translate = "translate(0, " + str(40 * i) + ")"
+ total = data[0].changed
- total = data_repos[0].changed
repo = Group(transform=translate)
+ repo.add(d.text(data[i].repo, insert=(2, 15), class_="lang-name"))
- repo.add(d.text(data_repos[i].repo, insert=(2, 15), class_="lang-name"))
repo.add(
- d.text(
- format_number(data_repos[i].changed),
- insert=(215, 33),
- class_="lang-name",
- )
+ d.text(format_number(data[i].changed), insert=(215, 33), class_="lang-name")
)
progress = Drawing(width="205", x="0", y="25")
progress.add(d.rect(size=(205, 8), insert=(0, 0</s>
===========changed ref 1===========
# module: backend.src.svg.top_repos
+ def get_top_repos_svg(data: List[RepoStats]) -> Drawing:
- def get_top_repos_svg(data: Any) -> Drawing:
# offset: 1
<s>", x="0", y="25")
progress.add(d.rect(size=(205, 8), insert=(0, 0), rx=5, ry=5, fill="#ddd"))
total_percent = 0
+ for j, lang in enumerate(data[i].langs):
- for j, lang in enumerate(data_repos[i].langs):
percent, color = 100 * (lang.additions + lang.deletions) / total, lang.color
box_size, box_insert = (2.05 * percent, 8), (2.05 * total_percent, 0)
progress.add(
d.rect(size=box_size, insert=box_insert, rx=5, ry=5, fill=color)
)
+ box_left, box_right = j > 0, j < len(data[i].langs) - 1
- box_left, box_right = j > 0, j < len(data_repos[i].langs) - 1
box_size = 2.05 * percent - (0 if box_left else 5) - (0 if box_right else 5)
box_insert = 2.05 * total_percent + (5 if not box_left else 0)
progress.add(
d.rect(size=(max(box_size, 3), 8), insert=(box_insert, 0), fill=color)
)
total_percent += percent
repo.add(progress)
repos.add(repo)
d.add(repos)
return d
|
backend.src.db.functions.get/get_user_by_access_token
|
Modified
|
avgupta456~github-trends
|
ddea0bdefa9da1ded7c0c04d7eb7f6ae58ac517b
|
fix svgs, check mongodb timing
|
<0>:<add> start = datetime.now()
<5>:<add> output = UserModel.parse_obj(user)
<del> return UserModel.parse_obj(user)
|
# module: backend.src.db.functions.get
def get_user_by_access_token(access_token: str) -> Optional[UserModel]:
<0> user: Optional[Dict[str, Any]] = await USERS.find_one( # type: ignore
<1> {"access_token": access_token}
<2> )
<3> if user is None:
<4> return None
<5> return UserModel.parse_obj(user)
<6>
|
===========unchanged ref 0===========
at: backend.src.db.functions.get.get_user_by_user_id
start = datetime.now()
output = UserModel.parse_obj(user)
at: datetime
datetime()
at: datetime.datetime
now(tz: Optional[_tzinfo]=...) -> _S
===========changed ref 0===========
# module: backend.src.db.functions.get
def get_user_by_user_id(user_id: str) -> Optional[UserModel]:
+ start = datetime.now()
user: Optional[Dict[str, Any]] = await USERS.find_one({"user_id": user_id}) # type: ignore
if user is None:
return None
+ output = UserModel.parse_obj(user)
- return UserModel.parse_obj(user)
===========changed ref 1===========
# module: backend.src.svg.top_repos
+ def get_top_repos_svg(data: List[RepoStats]) -> Drawing:
- def get_top_repos_svg(data: Any) -> Drawing:
d = Drawing(size=(300, 285))
d.defs.add(d.style(style))
d.add(
d.rect(
size=(299, 284),
insert=(0.5, 0.5),
rx=4.5,
stroke="#e4e2e2",
fill="#fffefe",
)
)
d.add(d.text("Most Contributed Repositories", insert=(25, 35), class_="header"))
repos = Group(transform="translate(25, 55)")
-
- if data.top_repos is None:
- raise ValueError("No repository data available")
- data_repos = data.top_repos
-
+ for i in range(min(5, len(data))):
- for i in range(min(5, len(data_repos))):
translate = "translate(0, " + str(40 * i) + ")"
+ total = data[0].changed
- total = data_repos[0].changed
repo = Group(transform=translate)
+ repo.add(d.text(data[i].repo, insert=(2, 15), class_="lang-name"))
- repo.add(d.text(data_repos[i].repo, insert=(2, 15), class_="lang-name"))
repo.add(
- d.text(
- format_number(data_repos[i].changed),
- insert=(215, 33),
- class_="lang-name",
- )
+ d.text(format_number(data[i].changed), insert=(215, 33), class_="lang-name")
)
progress = Drawing(width="205", x="0", y="25")
progress.add(d.rect(size=(205, 8), insert=(0, 0</s>
===========changed ref 2===========
# module: backend.src.svg.top_repos
+ def get_top_repos_svg(data: List[RepoStats]) -> Drawing:
- def get_top_repos_svg(data: Any) -> Drawing:
# offset: 1
<s>", x="0", y="25")
progress.add(d.rect(size=(205, 8), insert=(0, 0), rx=5, ry=5, fill="#ddd"))
total_percent = 0
+ for j, lang in enumerate(data[i].langs):
- for j, lang in enumerate(data_repos[i].langs):
percent, color = 100 * (lang.additions + lang.deletions) / total, lang.color
box_size, box_insert = (2.05 * percent, 8), (2.05 * total_percent, 0)
progress.add(
d.rect(size=box_size, insert=box_insert, rx=5, ry=5, fill=color)
)
+ box_left, box_right = j > 0, j < len(data[i].langs) - 1
- box_left, box_right = j > 0, j < len(data_repos[i].langs) - 1
box_size = 2.05 * percent - (0 if box_left else 5) - (0 if box_right else 5)
box_insert = 2.05 * total_percent + (5 if not box_left else 0)
progress.add(
d.rect(size=(max(box_size, 3), 8), insert=(box_insert, 0), fill=color)
)
total_percent += percent
repo.add(progress)
repos.add(repo)
d.add(repos)
return d
|
backend.src.utils/svg_fail_gracefully
|
Modified
|
avgupta456~github-trends
|
ddea0bdefa9da1ded7c0c04d7eb7f6ae58ac517b
|
fix svgs, check mongodb timing
|
<6>:<add> start = datetime.now()
<17>:<add> print(datetime.now() - start)
<add>
|
# module: backend.src.utils
# NOTE: implied async, sync not implemented yet
def svg_fail_gracefully(func: Callable[..., Any]):
<0> @wraps(func) # needed to play nice with FastAPI decorator
<1> async def wrapper(
<2> response: Response, *args: List[Any], **kwargs: Dict[str, Any]
<3> ) -> Any:
<4> d: Drawing
<5> status_code: int
<6> try:
<7> d = await func(response, *args, **kwargs)
<8> status_code = status.HTTP_200_OK
<9> except Exception as e:
<10> logging.exception(e)
<11> d = get_error_svg()
<12> status_code = status.HTTP_200_OK
<13>
<14> sio = io.StringIO()
<15> d.write(sio) # type: ignore
<16>
<17> return Response(
<18> sio.getvalue(), media_type="image/svg+xml", status_code=status_code
<19> )
<20>
<21> return wrapper
<22>
|
===========unchanged ref 0===========
at: datetime
datetime()
at: datetime.datetime
__slots__ = date.__slots__ + time.__slots__
now(tz: Optional[_tzinfo]=...) -> _S
__radd__ = __add__
at: functools
wraps(wrapped: _AnyCallable, assigned: Sequence[str]=..., updated: Sequence[str]=...) -> Callable[[_T], _T]
at: io
StringIO(initial_value: Optional[str]=..., newline: Optional[str]=...)
at: io.StringIO
getvalue(self) -> str
at: logging
exception(msg: Any, *args: Any, exc_info: _ExcInfoType=..., stack_info: bool=..., extra: Optional[Dict[str, Any]]=..., **kwargs: Any) -> None
at: src.svg.error
get_error_svg() -> Drawing
at: typing
Callable = _CallableType(collections.abc.Callable, 2)
List = _alias(list, 1, inst=False, name='List')
Dict = _alias(dict, 2, inst=False, name='Dict')
===========changed ref 0===========
# module: backend.src.db.functions.get
def get_user_by_user_id(user_id: str) -> Optional[UserModel]:
+ start = datetime.now()
user: Optional[Dict[str, Any]] = await USERS.find_one({"user_id": user_id}) # type: ignore
if user is None:
return None
+ output = UserModel.parse_obj(user)
- return UserModel.parse_obj(user)
===========changed ref 1===========
# module: backend.src.db.functions.get
def get_user_by_access_token(access_token: str) -> Optional[UserModel]:
+ start = datetime.now()
user: Optional[Dict[str, Any]] = await USERS.find_one( # type: ignore
{"access_token": access_token}
)
if user is None:
return None
+ output = UserModel.parse_obj(user)
- return UserModel.parse_obj(user)
===========changed ref 2===========
# module: backend.src.svg.top_repos
+ def get_top_repos_svg(data: List[RepoStats]) -> Drawing:
- def get_top_repos_svg(data: Any) -> Drawing:
d = Drawing(size=(300, 285))
d.defs.add(d.style(style))
d.add(
d.rect(
size=(299, 284),
insert=(0.5, 0.5),
rx=4.5,
stroke="#e4e2e2",
fill="#fffefe",
)
)
d.add(d.text("Most Contributed Repositories", insert=(25, 35), class_="header"))
repos = Group(transform="translate(25, 55)")
-
- if data.top_repos is None:
- raise ValueError("No repository data available")
- data_repos = data.top_repos
-
+ for i in range(min(5, len(data))):
- for i in range(min(5, len(data_repos))):
translate = "translate(0, " + str(40 * i) + ")"
+ total = data[0].changed
- total = data_repos[0].changed
repo = Group(transform=translate)
+ repo.add(d.text(data[i].repo, insert=(2, 15), class_="lang-name"))
- repo.add(d.text(data_repos[i].repo, insert=(2, 15), class_="lang-name"))
repo.add(
- d.text(
- format_number(data_repos[i].changed),
- insert=(215, 33),
- class_="lang-name",
- )
+ d.text(format_number(data[i].changed), insert=(215, 33), class_="lang-name")
)
progress = Drawing(width="205", x="0", y="25")
progress.add(d.rect(size=(205, 8), insert=(0, 0</s>
===========changed ref 3===========
# module: backend.src.svg.top_repos
+ def get_top_repos_svg(data: List[RepoStats]) -> Drawing:
- def get_top_repos_svg(data: Any) -> Drawing:
# offset: 1
<s>", x="0", y="25")
progress.add(d.rect(size=(205, 8), insert=(0, 0), rx=5, ry=5, fill="#ddd"))
total_percent = 0
+ for j, lang in enumerate(data[i].langs):
- for j, lang in enumerate(data_repos[i].langs):
percent, color = 100 * (lang.additions + lang.deletions) / total, lang.color
box_size, box_insert = (2.05 * percent, 8), (2.05 * total_percent, 0)
progress.add(
d.rect(size=box_size, insert=box_insert, rx=5, ry=5, fill=color)
)
+ box_left, box_right = j > 0, j < len(data[i].langs) - 1
- box_left, box_right = j > 0, j < len(data_repos[i].langs) - 1
box_size = 2.05 * percent - (0 if box_left else 5) - (0 if box_right else 5)
box_insert = 2.05 * total_percent + (5 if not box_left else 0)
progress.add(
d.rect(size=(max(box_size, 3), 8), insert=(box_insert, 0), fill=color)
)
total_percent += percent
repo.add(progress)
repos.add(repo)
d.add(repos)
return d
|
backend.src.routers.users/_get_user
|
Modified
|
avgupta456~github-trends
|
ddea0bdefa9da1ded7c0c04d7eb7f6ae58ac517b
|
fix svgs, check mongodb timing
|
<0>:<del> if not PUBSUB_PUB:
<1>:<del> raise HTTPException(400, "")
<2>:<add> output = await __get_user(user_id)
<3>:<del> db_user = await get_user_by_user_id(user_id)
<4>:<del> if db_user is None or db_user.access_token == "":
<5>:<del> raise LookupError("Invalid UserId")
<6>:<add> if output is None:
<add> return None
<7>:<del> time_diff = datetime.now() - db_user.last_updated
<8>:<del> if time_diff > timedelta(hours=6) or not validate_raw_data(db_user.raw_data):
<9>:<del> if not db_user.lock:
<10>:<del> publish_to_topic(
<11>:<del> "user", {"user_id": user_id, "access_token": db_user.access_token}
<12>:<del> )
<13>:<add> output = trim_package(output, start_date, end_date)
<14>:<del> if validate_raw_data(db_user.raw_data):
<15>:<del> return db_user.raw_data # type: ignore
<16>:<add> # TODO: handle timezone_str here
<17>:<add> return output
<del> return None
|
# module: backend.src.routers.users
+ def _get_user(
+ user_id: str, start_date: date, end_date: date
+ ) -> Optional[UserPackage]:
- def _get_user(user_id: str) -> Optional[UserPackage]:
<0> if not PUBSUB_PUB:
<1> raise HTTPException(400, "")
<2>
<3> db_user = await get_user_by_user_id(user_id)
<4> if db_user is None or db_user.access_token == "":
<5> raise LookupError("Invalid UserId")
<6>
<7> time_diff = datetime.now() - db_user.last_updated
<8> if time_diff > timedelta(hours=6) or not validate_raw_data(db_user.raw_data):
<9> if not db_user.lock:
<10> publish_to_topic(
<11> "user", {"user_id": user_id, "access_token": db_user.access_token}
<12> )
<13>
<14> if validate_raw_data(db_user.raw_data):
<15> return db_user.raw_data # type: ignore
<16>
<17> return None
<18>
|
===========unchanged ref 0===========
at: backend.src.routers.users
validate_raw_data(data: Optional[UserPackage]) -> bool
at: datetime
timedelta(days: float=..., seconds: float=..., microseconds: float=..., milliseconds: float=..., minutes: float=..., hours: float=..., weeks: float=..., *, fold: int=...)
datetime()
at: datetime.datetime
__slots__ = date.__slots__ + time.__slots__
now(tz: Optional[_tzinfo]=...) -> _S
__radd__ = __add__
at: src.constants
PUBSUB_PUB = os.getenv("PUBSUB_PUB", "False") == "True"
at: src.db.functions.get
get_user_by_user_id(user_id: str) -> Optional[UserModel]
at: src.db.models.users.UserModel
user_id: str
access_token: str
last_updated: datetime
raw_data: Optional[UserPackage]
lock: bool
at: src.external.pubsub.templates
publish_to_topic(topic: str, message: Dict[str, Any]) -> None
===========changed ref 0===========
# module: backend.src.db.functions.get
def get_user_by_user_id(user_id: str) -> Optional[UserModel]:
+ start = datetime.now()
user: Optional[Dict[str, Any]] = await USERS.find_one({"user_id": user_id}) # type: ignore
if user is None:
return None
+ output = UserModel.parse_obj(user)
- return UserModel.parse_obj(user)
===========changed ref 1===========
# module: backend.src.db.functions.get
def get_user_by_access_token(access_token: str) -> Optional[UserModel]:
+ start = datetime.now()
user: Optional[Dict[str, Any]] = await USERS.find_one( # type: ignore
{"access_token": access_token}
)
if user is None:
return None
+ output = UserModel.parse_obj(user)
- return UserModel.parse_obj(user)
===========changed ref 2===========
# module: backend.src.utils
# NOTE: implied async, sync not implemented yet
def svg_fail_gracefully(func: Callable[..., Any]):
@wraps(func) # needed to play nice with FastAPI decorator
async def wrapper(
response: Response, *args: List[Any], **kwargs: Dict[str, Any]
) -> Any:
d: Drawing
status_code: int
+ start = datetime.now()
try:
d = await func(response, *args, **kwargs)
status_code = status.HTTP_200_OK
except Exception as e:
logging.exception(e)
d = get_error_svg()
status_code = status.HTTP_200_OK
sio = io.StringIO()
d.write(sio) # type: ignore
+ print(datetime.now() - start)
+
return Response(
sio.getvalue(), media_type="image/svg+xml", status_code=status_code
)
return wrapper
===========changed ref 3===========
# module: backend.src.svg.top_repos
+ def get_top_repos_svg(data: List[RepoStats]) -> Drawing:
- def get_top_repos_svg(data: Any) -> Drawing:
d = Drawing(size=(300, 285))
d.defs.add(d.style(style))
d.add(
d.rect(
size=(299, 284),
insert=(0.5, 0.5),
rx=4.5,
stroke="#e4e2e2",
fill="#fffefe",
)
)
d.add(d.text("Most Contributed Repositories", insert=(25, 35), class_="header"))
repos = Group(transform="translate(25, 55)")
-
- if data.top_repos is None:
- raise ValueError("No repository data available")
- data_repos = data.top_repos
-
+ for i in range(min(5, len(data))):
- for i in range(min(5, len(data_repos))):
translate = "translate(0, " + str(40 * i) + ")"
+ total = data[0].changed
- total = data_repos[0].changed
repo = Group(transform=translate)
+ repo.add(d.text(data[i].repo, insert=(2, 15), class_="lang-name"))
- repo.add(d.text(data_repos[i].repo, insert=(2, 15), class_="lang-name"))
repo.add(
- d.text(
- format_number(data_repos[i].changed),
- insert=(215, 33),
- class_="lang-name",
- )
+ d.text(format_number(data[i].changed), insert=(215, 33), class_="lang-name")
)
progress = Drawing(width="205", x="0", y="25")
progress.add(d.rect(size=(205, 8), insert=(0, 0</s>
===========changed ref 4===========
# module: backend.src.svg.top_repos
+ def get_top_repos_svg(data: List[RepoStats]) -> Drawing:
- def get_top_repos_svg(data: Any) -> Drawing:
# offset: 1
<s>", x="0", y="25")
progress.add(d.rect(size=(205, 8), insert=(0, 0), rx=5, ry=5, fill="#ddd"))
total_percent = 0
+ for j, lang in enumerate(data[i].langs):
- for j, lang in enumerate(data_repos[i].langs):
percent, color = 100 * (lang.additions + lang.deletions) / total, lang.color
box_size, box_insert = (2.05 * percent, 8), (2.05 * total_percent, 0)
progress.add(
d.rect(size=box_size, insert=box_insert, rx=5, ry=5, fill=color)
)
+ box_left, box_right = j > 0, j < len(data[i].langs) - 1
- box_left, box_right = j > 0, j < len(data_repos[i].langs) - 1
box_size = 2.05 * percent - (0 if box_left else 5) - (0 if box_right else 5)
box_insert = 2.05 * total_percent + (5 if not box_left else 0)
progress.add(
d.rect(size=(max(box_size, 3), 8), insert=(box_insert, 0), fill=color)
)
total_percent += percent
repo.add(progress)
repos.add(repo)
d.add(repos)
return d
|
backend.src.routers.users/get_user
|
Modified
|
avgupta456~github-trends
|
ddea0bdefa9da1ded7c0c04d7eb7f6ae58ac517b
|
fix svgs, check mongodb timing
|
<0>:<add> return await _get_user(user_id, start_date, end_date)
<del> output = await _get_user(user_id)
<2>:<del> if output is None:
<3>:<del> return None
<4>:<del>
<5>:<del> output = trim_package(output)
<6>:<del>
<7>:<del> return output
<8>:<del>
|
<s> status_code=status.HTTP_200_OK)
@async_fail_gracefully
+ async def get_user(
+ response: Response,
+ user_id: str,
+ start_date: date = date.today() - timedelta(365),
+ end_date: date = date.today(),
+ timezone_str: str = "US/Eastern",
+ ) -> Optional[UserPackage]:
- async def get_user(response: Response, user_id: str) -> Optional[UserPackage]:
<0> output = await _get_user(user_id)
<1>
<2> if output is None:
<3> return None
<4>
<5> output = trim_package(output)
<6>
<7> return output
<8>
|
===========unchanged ref 0===========
at: backend.src.routers.users
__get_user(user_id: str) -> Optional[UserPackage]
at: datetime
date()
===========changed ref 0===========
# module: backend.src.routers.users
+ def __get_user(user_id: str) -> Optional[UserPackage]:
+ if not PUBSUB_PUB:
+ raise HTTPException(400, "")
+
+ db_user = await get_user_by_user_id(user_id)
+ if db_user is None or db_user.access_token == "":
+ raise LookupError("Invalid UserId")
+
+ time_diff = datetime.now() - db_user.last_updated
+ if time_diff > timedelta(hours=6) or not validate_raw_data(db_user.raw_data):
+ if not db_user.lock:
+ publish_to_topic(
+ "user", {"user_id": user_id, "access_token": db_user.access_token}
+ )
+
+ if validate_raw_data(db_user.raw_data):
+ return db_user.raw_data # type: ignore
+
+ return None
+
===========changed ref 1===========
# module: backend.src.routers.users
+ def _get_user(
+ user_id: str, start_date: date, end_date: date
+ ) -> Optional[UserPackage]:
- def _get_user(user_id: str) -> Optional[UserPackage]:
- if not PUBSUB_PUB:
- raise HTTPException(400, "")
+ output = await __get_user(user_id)
- db_user = await get_user_by_user_id(user_id)
- if db_user is None or db_user.access_token == "":
- raise LookupError("Invalid UserId")
+ if output is None:
+ return None
- time_diff = datetime.now() - db_user.last_updated
- if time_diff > timedelta(hours=6) or not validate_raw_data(db_user.raw_data):
- if not db_user.lock:
- publish_to_topic(
- "user", {"user_id": user_id, "access_token": db_user.access_token}
- )
+ output = trim_package(output, start_date, end_date)
- if validate_raw_data(db_user.raw_data):
- return db_user.raw_data # type: ignore
+ # TODO: handle timezone_str here
+ return output
- return None
===========changed ref 2===========
# module: backend.src.db.functions.get
def get_user_by_user_id(user_id: str) -> Optional[UserModel]:
+ start = datetime.now()
user: Optional[Dict[str, Any]] = await USERS.find_one({"user_id": user_id}) # type: ignore
if user is None:
return None
+ output = UserModel.parse_obj(user)
- return UserModel.parse_obj(user)
===========changed ref 3===========
# module: backend.src.db.functions.get
def get_user_by_access_token(access_token: str) -> Optional[UserModel]:
+ start = datetime.now()
user: Optional[Dict[str, Any]] = await USERS.find_one( # type: ignore
{"access_token": access_token}
)
if user is None:
return None
+ output = UserModel.parse_obj(user)
- return UserModel.parse_obj(user)
===========changed ref 4===========
# module: backend.src.utils
# NOTE: implied async, sync not implemented yet
def svg_fail_gracefully(func: Callable[..., Any]):
@wraps(func) # needed to play nice with FastAPI decorator
async def wrapper(
response: Response, *args: List[Any], **kwargs: Dict[str, Any]
) -> Any:
d: Drawing
status_code: int
+ start = datetime.now()
try:
d = await func(response, *args, **kwargs)
status_code = status.HTTP_200_OK
except Exception as e:
logging.exception(e)
d = get_error_svg()
status_code = status.HTTP_200_OK
sio = io.StringIO()
d.write(sio) # type: ignore
+ print(datetime.now() - start)
+
return Response(
sio.getvalue(), media_type="image/svg+xml", status_code=status_code
)
return wrapper
===========changed ref 5===========
# module: backend.src.svg.top_repos
+ def get_top_repos_svg(data: List[RepoStats]) -> Drawing:
- def get_top_repos_svg(data: Any) -> Drawing:
d = Drawing(size=(300, 285))
d.defs.add(d.style(style))
d.add(
d.rect(
size=(299, 284),
insert=(0.5, 0.5),
rx=4.5,
stroke="#e4e2e2",
fill="#fffefe",
)
)
d.add(d.text("Most Contributed Repositories", insert=(25, 35), class_="header"))
repos = Group(transform="translate(25, 55)")
-
- if data.top_repos is None:
- raise ValueError("No repository data available")
- data_repos = data.top_repos
-
+ for i in range(min(5, len(data))):
- for i in range(min(5, len(data_repos))):
translate = "translate(0, " + str(40 * i) + ")"
+ total = data[0].changed
- total = data_repos[0].changed
repo = Group(transform=translate)
+ repo.add(d.text(data[i].repo, insert=(2, 15), class_="lang-name"))
- repo.add(d.text(data_repos[i].repo, insert=(2, 15), class_="lang-name"))
repo.add(
- d.text(
- format_number(data_repos[i].changed),
- insert=(215, 33),
- class_="lang-name",
- )
+ d.text(format_number(data[i].changed), insert=(215, 33), class_="lang-name")
)
progress = Drawing(width="205", x="0", y="25")
progress.add(d.rect(size=(205, 8), insert=(0, 0</s>
|
backend.src.routers.users/get_user_lang_svg
|
Modified
|
avgupta456~github-trends
|
ddea0bdefa9da1ded7c0c04d7eb7f6ae58ac517b
|
fix svgs, check mongodb timing
|
<0>:<add> output = await _get_user(user_id, start_date, end_date)
<del> output = await _get_user(user_id)
<1>:<add> if output is None:
<del> if not validate_raw_data(output):
<3>:<add> processed = get_top_languages(output)
<add> return get_top_langs_svg(processed, use_percent)
<del> return get_top_langs_svg(output, use_percent) # type: ignore
|
<s> "/{user_id}/svg/langs", status_code=status.HTTP_200_OK, response_class=HTMLResponse
)
@svg_fail_gracefully
async def get_user_lang_svg(
response: Response,
user_id: str,
start_date: date = date.today() - timedelta(365),
end_date: date = date.today(),
timezone_str: str = "US/Eastern",
use_percent: bool = True,
) -> Any:
<0> output = await _get_user(user_id)
<1> if not validate_raw_data(output):
<2> return get_loading_svg()
<3> return get_top_langs_svg(output, use_percent) # type: ignore
<4>
|
===========unchanged ref 0===========
at: backend.src.routers.users
router = APIRouter()
_get_user(user_id: str, start_date: date, end_date: date) -> Optional[UserPackage]
at: backend.src.routers.users._get_user
output = trim_package(output, start_date, end_date)
output = await __get_user(user_id)
at: datetime
timedelta(days: float=..., seconds: float=..., microseconds: float=..., milliseconds: float=..., minutes: float=..., hours: float=..., weeks: float=..., *, fold: int=...)
date()
at: datetime.date
__slots__ = '_year', '_month', '_day', '_hashcode'
today() -> _S
__str__ = isoformat
__radd__ = __add__
at: src.utils
async_fail_gracefully(func: Callable[..., Any])
===========changed ref 0===========
# module: backend.src.routers.users
+ def _get_user(
+ user_id: str, start_date: date, end_date: date
+ ) -> Optional[UserPackage]:
- def _get_user(user_id: str) -> Optional[UserPackage]:
- if not PUBSUB_PUB:
- raise HTTPException(400, "")
+ output = await __get_user(user_id)
- db_user = await get_user_by_user_id(user_id)
- if db_user is None or db_user.access_token == "":
- raise LookupError("Invalid UserId")
+ if output is None:
+ return None
- time_diff = datetime.now() - db_user.last_updated
- if time_diff > timedelta(hours=6) or not validate_raw_data(db_user.raw_data):
- if not db_user.lock:
- publish_to_topic(
- "user", {"user_id": user_id, "access_token": db_user.access_token}
- )
+ output = trim_package(output, start_date, end_date)
- if validate_raw_data(db_user.raw_data):
- return db_user.raw_data # type: ignore
+ # TODO: handle timezone_str here
+ return output
- return None
===========changed ref 1===========
<s> status_code=status.HTTP_200_OK)
@async_fail_gracefully
+ async def get_user(
+ response: Response,
+ user_id: str,
+ start_date: date = date.today() - timedelta(365),
+ end_date: date = date.today(),
+ timezone_str: str = "US/Eastern",
+ ) -> Optional[UserPackage]:
- async def get_user(response: Response, user_id: str) -> Optional[UserPackage]:
+ return await _get_user(user_id, start_date, end_date)
- output = await _get_user(user_id)
- if output is None:
- return None
-
- output = trim_package(output)
-
- return output
-
===========changed ref 2===========
# module: backend.src.routers.users
+ def __get_user(user_id: str) -> Optional[UserPackage]:
+ if not PUBSUB_PUB:
+ raise HTTPException(400, "")
+
+ db_user = await get_user_by_user_id(user_id)
+ if db_user is None or db_user.access_token == "":
+ raise LookupError("Invalid UserId")
+
+ time_diff = datetime.now() - db_user.last_updated
+ if time_diff > timedelta(hours=6) or not validate_raw_data(db_user.raw_data):
+ if not db_user.lock:
+ publish_to_topic(
+ "user", {"user_id": user_id, "access_token": db_user.access_token}
+ )
+
+ if validate_raw_data(db_user.raw_data):
+ return db_user.raw_data # type: ignore
+
+ return None
+
===========changed ref 3===========
# module: backend.src.db.functions.get
def get_user_by_user_id(user_id: str) -> Optional[UserModel]:
+ start = datetime.now()
user: Optional[Dict[str, Any]] = await USERS.find_one({"user_id": user_id}) # type: ignore
if user is None:
return None
+ output = UserModel.parse_obj(user)
- return UserModel.parse_obj(user)
===========changed ref 4===========
# module: backend.src.db.functions.get
def get_user_by_access_token(access_token: str) -> Optional[UserModel]:
+ start = datetime.now()
user: Optional[Dict[str, Any]] = await USERS.find_one( # type: ignore
{"access_token": access_token}
)
if user is None:
return None
+ output = UserModel.parse_obj(user)
- return UserModel.parse_obj(user)
===========changed ref 5===========
# module: backend.src.utils
# NOTE: implied async, sync not implemented yet
def svg_fail_gracefully(func: Callable[..., Any]):
@wraps(func) # needed to play nice with FastAPI decorator
async def wrapper(
response: Response, *args: List[Any], **kwargs: Dict[str, Any]
) -> Any:
d: Drawing
status_code: int
+ start = datetime.now()
try:
d = await func(response, *args, **kwargs)
status_code = status.HTTP_200_OK
except Exception as e:
logging.exception(e)
d = get_error_svg()
status_code = status.HTTP_200_OK
sio = io.StringIO()
d.write(sio) # type: ignore
+ print(datetime.now() - start)
+
return Response(
sio.getvalue(), media_type="image/svg+xml", status_code=status_code
)
return wrapper
|
backend.src.routers.users/get_user_repo_svg
|
Modified
|
avgupta456~github-trends
|
ddea0bdefa9da1ded7c0c04d7eb7f6ae58ac517b
|
fix svgs, check mongodb timing
|
<0>:<add> output = await _get_user(user_id, start_date, end_date)
<del> output = await _get_user(user_id)
<1>:<add> if output is None:
<del> if not validate_raw_data(output):
<3>:<add> processed = get_top_repos(output)
<add> return get_top_repos_svg(processed)
<del> return get_top_repos_svg(output) # type: ignore
|
<s>routers.users
@router.get(
"/{user_id}/svg/repos", status_code=status.HTTP_200_OK, response_class=HTMLResponse
)
@svg_fail_gracefully
async def get_user_repo_svg(
response: Response,
user_id: str,
start_date: date = date.today() - timedelta(365),
end_date: date = date.today(),
timezone_str: str = "US/Eastern",
) -> Any:
<0> output = await _get_user(user_id)
<1> if not validate_raw_data(output):
<2> return get_loading_svg()
<3> return get_top_repos_svg(output) # type: ignore
<4>
|
===========unchanged ref 0===========
at: backend.src.routers.users
router = APIRouter()
_get_user(user_id: str, start_date: date, end_date: date) -> Optional[UserPackage]
at: datetime
timedelta(days: float=..., seconds: float=..., microseconds: float=..., milliseconds: float=..., minutes: float=..., hours: float=..., weeks: float=..., *, fold: int=...)
date()
at: datetime.date
today() -> _S
at: src.svg.error
get_loading_svg() -> Drawing
at: src.utils
svg_fail_gracefully(func: Callable[..., Any])
===========changed ref 0===========
# module: backend.src.routers.users
+ def _get_user(
+ user_id: str, start_date: date, end_date: date
+ ) -> Optional[UserPackage]:
- def _get_user(user_id: str) -> Optional[UserPackage]:
- if not PUBSUB_PUB:
- raise HTTPException(400, "")
+ output = await __get_user(user_id)
- db_user = await get_user_by_user_id(user_id)
- if db_user is None or db_user.access_token == "":
- raise LookupError("Invalid UserId")
+ if output is None:
+ return None
- time_diff = datetime.now() - db_user.last_updated
- if time_diff > timedelta(hours=6) or not validate_raw_data(db_user.raw_data):
- if not db_user.lock:
- publish_to_topic(
- "user", {"user_id": user_id, "access_token": db_user.access_token}
- )
+ output = trim_package(output, start_date, end_date)
- if validate_raw_data(db_user.raw_data):
- return db_user.raw_data # type: ignore
+ # TODO: handle timezone_str here
+ return output
- return None
===========changed ref 1===========
<s> status_code=status.HTTP_200_OK)
@async_fail_gracefully
+ async def get_user(
+ response: Response,
+ user_id: str,
+ start_date: date = date.today() - timedelta(365),
+ end_date: date = date.today(),
+ timezone_str: str = "US/Eastern",
+ ) -> Optional[UserPackage]:
- async def get_user(response: Response, user_id: str) -> Optional[UserPackage]:
+ return await _get_user(user_id, start_date, end_date)
- output = await _get_user(user_id)
- if output is None:
- return None
-
- output = trim_package(output)
-
- return output
-
===========changed ref 2===========
<s> "/{user_id}/svg/langs", status_code=status.HTTP_200_OK, response_class=HTMLResponse
)
@svg_fail_gracefully
async def get_user_lang_svg(
response: Response,
user_id: str,
start_date: date = date.today() - timedelta(365),
end_date: date = date.today(),
timezone_str: str = "US/Eastern",
use_percent: bool = True,
) -> Any:
+ output = await _get_user(user_id, start_date, end_date)
- output = await _get_user(user_id)
+ if output is None:
- if not validate_raw_data(output):
return get_loading_svg()
+ processed = get_top_languages(output)
+ return get_top_langs_svg(processed, use_percent)
- return get_top_langs_svg(output, use_percent) # type: ignore
===========changed ref 3===========
# module: backend.src.routers.users
+ def __get_user(user_id: str) -> Optional[UserPackage]:
+ if not PUBSUB_PUB:
+ raise HTTPException(400, "")
+
+ db_user = await get_user_by_user_id(user_id)
+ if db_user is None or db_user.access_token == "":
+ raise LookupError("Invalid UserId")
+
+ time_diff = datetime.now() - db_user.last_updated
+ if time_diff > timedelta(hours=6) or not validate_raw_data(db_user.raw_data):
+ if not db_user.lock:
+ publish_to_topic(
+ "user", {"user_id": user_id, "access_token": db_user.access_token}
+ )
+
+ if validate_raw_data(db_user.raw_data):
+ return db_user.raw_data # type: ignore
+
+ return None
+
===========changed ref 4===========
# module: backend.src.db.functions.get
def get_user_by_user_id(user_id: str) -> Optional[UserModel]:
+ start = datetime.now()
user: Optional[Dict[str, Any]] = await USERS.find_one({"user_id": user_id}) # type: ignore
if user is None:
return None
+ output = UserModel.parse_obj(user)
- return UserModel.parse_obj(user)
===========changed ref 5===========
# module: backend.src.db.functions.get
def get_user_by_access_token(access_token: str) -> Optional[UserModel]:
+ start = datetime.now()
user: Optional[Dict[str, Any]] = await USERS.find_one( # type: ignore
{"access_token": access_token}
)
if user is None:
return None
+ output = UserModel.parse_obj(user)
- return UserModel.parse_obj(user)
===========changed ref 6===========
# module: backend.src.utils
# NOTE: implied async, sync not implemented yet
def svg_fail_gracefully(func: Callable[..., Any]):
@wraps(func) # needed to play nice with FastAPI decorator
async def wrapper(
response: Response, *args: List[Any], **kwargs: Dict[str, Any]
) -> Any:
d: Drawing
status_code: int
+ start = datetime.now()
try:
d = await func(response, *args, **kwargs)
status_code = status.HTTP_200_OK
except Exception as e:
logging.exception(e)
d = get_error_svg()
status_code = status.HTTP_200_OK
sio = io.StringIO()
d.write(sio) # type: ignore
+ print(datetime.now() - start)
+
return Response(
sio.getvalue(), media_type="image/svg+xml", status_code=status_code
)
return wrapper
|
backend.src.svg.top_langs/get_top_langs_svg
|
Modified
|
avgupta456~github-trends
|
ddea0bdefa9da1ded7c0c04d7eb7f6ae58ac517b
|
fix svgs, check mongodb timing
|
<17>:<del> if data.top_languages is None:
<18>:<del> raise ValueError("No language data available")
<19>:<del> data_langs = data.top_languages[1:]
<20>:<add> data_langs = data[1:] # exclude "Total"
|
# module: backend.src.svg.top_langs
+ def get_top_langs_svg(data: List[LanguageStats], use_percent: bool = True) -> Drawing:
- def get_top_langs_svg(data: Any, use_percent: bool = True) -> Drawing:
<0> d = Drawing(size=(300, 285))
<1> d.defs.add(d.style(style))
<2>
<3> d.add(
<4> d.rect(
<5> size=(299, 284),
<6> insert=(0.5, 0.5),
<7> rx=4.5,
<8> stroke="#e4e2e2",
<9> fill="#fffefe",
<10> )
<11> )
<12>
<13> d.add(d.text("Most Used Languages", insert=(25, 35), class_="header"))
<14>
<15> langs = Group(transform="translate(25, 55)")
<16>
<17> if data.top_languages is None:
<18> raise ValueError("No language data available")
<19> data_langs = data.top_languages[1:]
<20> for i in range(min(5, len(data_langs))):
<21> translate = "translate(0, " + str(40 * i) + ")"
<22> percent = (
<23> data_langs[i].percent
<24> if use_percent
<25> else 100 * data_langs[i].changed / data_langs[0].changed
<26> )
<27> color = data_langs[i].color or "#ededed"
<28> lang = Group(transform=translate)
<29> lang.add(d.text(data_langs[i].lang, insert=(2, 15), class_="lang-name"))
<30> if use_percent:
<31> lang.add(d.text(str(percent) + "%", insert=(215, 33), class_="lang-name"))
<32> else:
<33> lang.add(
<34> d.text(
<35> format_number(data_langs[i].changed),
<36> insert=(215, 33</s>
|
===========below chunk 0===========
# module: backend.src.svg.top_langs
+ def get_top_langs_svg(data: List[LanguageStats], use_percent: bool = True) -> Drawing:
- def get_top_langs_svg(data: Any, use_percent: bool = True) -> Drawing:
# offset: 1
class_="lang-name",
)
)
progress = Drawing(width="205", x="0", y="25")
progress.add(d.rect(size=(205, 8), insert=(0, 0), rx=5, ry=5, fill="#ddd"))
progress.add(
d.rect(
size=(2.05 * percent, 8),
insert=(0, 0),
rx=5,
ry=5,
fill=color,
)
)
lang.add(progress)
langs.add(lang)
d.add(langs)
return d
===========unchanged ref 0===========
at: backend.src.svg.top_langs
format_number(num: int) -> str
at: src.models.user.analytics.LanguageStats
lang: str
additions: int
deletions: int
added: int
changed: int
percent: float
color: Optional[str]
at: src.svg.style
style = """
.header {
font: 600 18px 'Segoe UI', Ubuntu, Sans-Serif;
fill: #2f80ed;
animation: fadeInAnimation 0.8s ease-in-out forwards;
}
.lang-name {
font: 400 11px 'Segoe UI', Ubuntu, Sans-Serif;
fill: #333;
}
@keyframes fadeInAnimation {
from {
opacity: 0;
}
to {
opacity: 1;
}
}
"""
at: typing
List = _alias(list, 1, inst=False, name='List')
===========changed ref 0===========
<s> status_code=status.HTTP_200_OK)
@async_fail_gracefully
+ async def get_user(
+ response: Response,
+ user_id: str,
+ start_date: date = date.today() - timedelta(365),
+ end_date: date = date.today(),
+ timezone_str: str = "US/Eastern",
+ ) -> Optional[UserPackage]:
- async def get_user(response: Response, user_id: str) -> Optional[UserPackage]:
+ return await _get_user(user_id, start_date, end_date)
- output = await _get_user(user_id)
- if output is None:
- return None
-
- output = trim_package(output)
-
- return output
-
===========changed ref 1===========
# module: backend.src.db.functions.get
def get_user_by_user_id(user_id: str) -> Optional[UserModel]:
+ start = datetime.now()
user: Optional[Dict[str, Any]] = await USERS.find_one({"user_id": user_id}) # type: ignore
if user is None:
return None
+ output = UserModel.parse_obj(user)
- return UserModel.parse_obj(user)
===========changed ref 2===========
# module: backend.src.db.functions.get
def get_user_by_access_token(access_token: str) -> Optional[UserModel]:
+ start = datetime.now()
user: Optional[Dict[str, Any]] = await USERS.find_one( # type: ignore
{"access_token": access_token}
)
if user is None:
return None
+ output = UserModel.parse_obj(user)
- return UserModel.parse_obj(user)
===========changed ref 3===========
<s>routers.users
@router.get(
"/{user_id}/svg/repos", status_code=status.HTTP_200_OK, response_class=HTMLResponse
)
@svg_fail_gracefully
async def get_user_repo_svg(
response: Response,
user_id: str,
start_date: date = date.today() - timedelta(365),
end_date: date = date.today(),
timezone_str: str = "US/Eastern",
) -> Any:
+ output = await _get_user(user_id, start_date, end_date)
- output = await _get_user(user_id)
+ if output is None:
- if not validate_raw_data(output):
return get_loading_svg()
+ processed = get_top_repos(output)
+ return get_top_repos_svg(processed)
- return get_top_repos_svg(output) # type: ignore
===========changed ref 4===========
<s> "/{user_id}/svg/langs", status_code=status.HTTP_200_OK, response_class=HTMLResponse
)
@svg_fail_gracefully
async def get_user_lang_svg(
response: Response,
user_id: str,
start_date: date = date.today() - timedelta(365),
end_date: date = date.today(),
timezone_str: str = "US/Eastern",
use_percent: bool = True,
) -> Any:
+ output = await _get_user(user_id, start_date, end_date)
- output = await _get_user(user_id)
+ if output is None:
- if not validate_raw_data(output):
return get_loading_svg()
+ processed = get_top_languages(output)
+ return get_top_langs_svg(processed, use_percent)
- return get_top_langs_svg(output, use_percent) # type: ignore
===========changed ref 5===========
# module: backend.src.routers.users
+ def __get_user(user_id: str) -> Optional[UserPackage]:
+ if not PUBSUB_PUB:
+ raise HTTPException(400, "")
+
+ db_user = await get_user_by_user_id(user_id)
+ if db_user is None or db_user.access_token == "":
+ raise LookupError("Invalid UserId")
+
+ time_diff = datetime.now() - db_user.last_updated
+ if time_diff > timedelta(hours=6) or not validate_raw_data(db_user.raw_data):
+ if not db_user.lock:
+ publish_to_topic(
+ "user", {"user_id": user_id, "access_token": db_user.access_token}
+ )
+
+ if validate_raw_data(db_user.raw_data):
+ return db_user.raw_data # type: ignore
+
+ return None
+
===========changed ref 6===========
# module: backend.src.utils
# NOTE: implied async, sync not implemented yet
def svg_fail_gracefully(func: Callable[..., Any]):
@wraps(func) # needed to play nice with FastAPI decorator
async def wrapper(
response: Response, *args: List[Any], **kwargs: Dict[str, Any]
) -> Any:
d: Drawing
status_code: int
+ start = datetime.now()
try:
d = await func(response, *args, **kwargs)
status_code = status.HTTP_200_OK
except Exception as e:
logging.exception(e)
d = get_error_svg()
status_code = status.HTTP_200_OK
sio = io.StringIO()
d.write(sio) # type: ignore
+ print(datetime.now() - start)
+
return Response(
sio.getvalue(), media_type="image/svg+xml", status_code=status_code
)
return wrapper
|
backend.src.analytics.user.utils/trim_package
|
Modified
|
avgupta456~github-trends
|
d4c042af15ea833aa35920c3cb9f7c7b2a3e5987
|
fully propagate start_date, end_date
|
<0>:<add> new_total, new_total_stats = trim_contribs(
<del> new_total, new_total_stats = trim_contribs(data.contribs.total)
<1>:<add> data.contribs.total, start_date, end_date
<add> )
<5>:<add> new_repo_total, new_repo_total_stats = trim_contribs(repo, start_date, end_date)
<del> new_repo_total, new_repo_total_stats = trim_contribs(repo)
|
# module: backend.src.analytics.user.utils
- def trim_package(
- data: UserPackage,
- start_date: date = date.today() - timedelta(365),
- end_date: date = date.today(),
- ) -> UserPackage:
+ def trim_package(data: UserPackage, start_date: date, end_date: date) -> UserPackage:
<0> new_total, new_total_stats = trim_contribs(data.contribs.total)
<1>
<2> new_repos = {}
<3> new_repo_stats = {}
<4> for repo_name, repo in data.contribs.repos.items():
<5> new_repo_total, new_repo_total_stats = trim_contribs(repo)
<6> if len(new_repo_total) > 0:
<7> new_repos[repo_name] = new_repo_total
<8> new_repo_stats[repo_name] = new_repo_total_stats
<9>
<10> new_data = {
<11> "total_stats": new_total_stats,
<12> "total": new_total,
<13> "repo_stats": new_repo_stats,
<14> "repos": new_repos,
<15> }
<16>
<17> return UserPackage.parse_obj({"contribs": new_data})
<18>
|
===========unchanged ref 0===========
at: backend.src.analytics.user.utils
trim_contribs(contribs: Union[List[ContributionDay], List[RepoContributionDay]], start_date: date, end_date: date) -> Tuple[List[Union[ContributionDay, RepoContributionDay]], Dict[str, Any]]
at: datetime
date()
at: src.models.user.contribs.UserContributions
total_stats: ContributionStats
total: List[RepoContributionDay]
repo_stats: Dict[str, ContributionStats]
repos: Dict[str, List[RepoContributionDay]]
at: src.models.user.package.UserPackage
contribs: UserContributions
|
backend.src.routers.pubsub/sub_user
|
Modified
|
avgupta456~github-trends
|
4b9019e03636082be53a16b40fb9c72996537b54
|
implement compression
|
<21>:<add> await update_user(data["user_id"], output)
<del> await update_user(data["user_id"], output.dict())
|
# module: backend.src.routers.pubsub
@router.post("/sub/user/{token}", status_code=status.HTTP_200_OK)
@pubsub_fail_gracefully
async def sub_user(response: Response, token: str, request: Request) -> Any:
<0> data: Dict[str, Any] = await parse_request(token, request)
<1>
<2> await lock_user(data["user_id"])
<3>
<4> # standard policy is to check past five years of data
<5> start_date = date.today() - timedelta(365 * 5)
<6> end_date = date.today()
<7> timezone_str = "US/Eastern"
<8>
<9> # TODO: historical data is never updated,
<10> # don't query full five years each time, instead
<11> # define function to build on previous results
<12>
<13> output = await get_data(
<14> data["user_id"],
<15> data["access_token"],
<16> start_date,
<17> end_date,
<18> timezone_str,
<19> )
<20>
<21> await update_user(data["user_id"], output.dict())
<22>
<23> await unlock_user(data["user_id"])
<24>
<25> return data
<26>
|
===========unchanged ref 0===========
at: backend.src.routers.pubsub
router = APIRouter()
at: datetime
timedelta(days: float=..., seconds: float=..., microseconds: float=..., milliseconds: float=..., minutes: float=..., hours: float=..., weeks: float=..., *, fold: int=...)
date()
at: datetime.date
__slots__ = '_year', '_month', '_day', '_hashcode'
today() -> _S
__str__ = isoformat
__radd__ = __add__
at: src.db.functions.users
lock_user(user_id: str) -> None
unlock_user(user_id: str) -> None
update_user(user_id: str, raw_data: Optional[UserPackage]=None) -> None
at: src.external.pubsub.templates
parse_request(token: str, request: Request) -> Dict[str, Any]
at: src.packaging.user
main(user_id: str, access_token: str, start_date: date, end_date: date, timezone_str: str="US/Eastern") -> UserPackage
at: src.utils
pubsub_fail_gracefully(func: Callable[..., Any])
at: typing
Dict = _alias(dict, 2, inst=False, name='Dict')
|
backend.src.db.functions.get/_get_user
|
Added
|
avgupta456~github-trends
|
4b9019e03636082be53a16b40fb9c72996537b54
|
implement compression
|
<0>:<add> if user is None:
<add> return None
<add>
<add> if "raw_data" not in user:
<add> return UserModel.parse_obj(user)
<add>
<add> raw_data = decompress(user["raw_data"])
<add> return UserModel.parse_obj({**user, "raw_data": raw_data})
<add>
|
# module: backend.src.db.functions.get
+ def _get_user(user: Optional[Dict[str, Any]]) -> Optional[UserModel]:
<0> <extra_id_1><extra_id_2><extra_id_3><extra_id_4><extra_id_5><extra_id_6><extra_id_7><extra_id_8>
|
===========unchanged ref 0===========
at: src.db.functions.compression
decompress(data: Dict[str, Any]) -> Dict[str, Any]
at: typing
Dict = _alias(dict, 2, inst=False, name='Dict')
===========changed ref 0===========
# module: backend.src.routers.pubsub
@router.post("/sub/user/{token}", status_code=status.HTTP_200_OK)
@pubsub_fail_gracefully
async def sub_user(response: Response, token: str, request: Request) -> Any:
data: Dict[str, Any] = await parse_request(token, request)
await lock_user(data["user_id"])
# standard policy is to check past five years of data
start_date = date.today() - timedelta(365 * 5)
end_date = date.today()
timezone_str = "US/Eastern"
# TODO: historical data is never updated,
# don't query full five years each time, instead
# define function to build on previous results
output = await get_data(
data["user_id"],
data["access_token"],
start_date,
end_date,
timezone_str,
)
+ await update_user(data["user_id"], output)
- await update_user(data["user_id"], output.dict())
await unlock_user(data["user_id"])
return data
|
backend.src.db.functions.get/_get_user
|
Modified
|
avgupta456~github-trends
|
4b9019e03636082be53a16b40fb9c72996537b54
|
implement compression
|
<0>:<add> if user is None:
<add> return None
<add>
<add> if "raw_data" not in user:
<add> return UserModel.parse_obj(user)
<add>
<add> raw_data = decompress(user["raw_data"])
<add> return UserModel.parse_obj({**user, "raw_data": raw_data})
<add>
|
# module: backend.src.db.functions.get
+ def _get_user(user: Optional[Dict[str, Any]]) -> Optional[UserModel]:
<0> <extra_id_1><extra_id_2><extra_id_3><extra_id_4><extra_id_5><extra_id_6><extra_id_7><extra_id_8>
|
===========unchanged ref 0===========
at: src.db.functions.compression
decompress(data: Dict[str, Any]) -> Dict[str, Any]
at: typing
Dict = _alias(dict, 2, inst=False, name='Dict')
===========changed ref 0===========
# module: backend.src.db.functions.get
+ def _get_user(user: Optional[Dict[str, Any]]) -> Optional[UserModel]:
+ if user is None:
+ return None
+
+ if "raw_data" not in user:
+ return UserModel.parse_obj(user)
+
+ raw_data = decompress(user["raw_data"])
+ return UserModel.parse_obj({**user, "raw_data": raw_data})
+
===========changed ref 1===========
# module: backend.src.routers.pubsub
@router.post("/sub/user/{token}", status_code=status.HTTP_200_OK)
@pubsub_fail_gracefully
async def sub_user(response: Response, token: str, request: Request) -> Any:
data: Dict[str, Any] = await parse_request(token, request)
await lock_user(data["user_id"])
# standard policy is to check past five years of data
start_date = date.today() - timedelta(365 * 5)
end_date = date.today()
timezone_str = "US/Eastern"
# TODO: historical data is never updated,
# don't query full five years each time, instead
# define function to build on previous results
output = await get_data(
data["user_id"],
data["access_token"],
start_date,
end_date,
timezone_str,
)
+ await update_user(data["user_id"], output)
- await update_user(data["user_id"], output.dict())
await unlock_user(data["user_id"])
return data
|
backend.src.db.functions.get/get_user_by_access_token
|
Modified
|
avgupta456~github-trends
|
4b9019e03636082be53a16b40fb9c72996537b54
|
implement compression
|
<0>:<del> start = datetime.now()
<4>:<del> if user is None:
<5>:<del> return None
<6>:<del> output = UserModel.parse_obj(user)
<7>:<del>
<8>:<del> print("MongoDB User Query:", datetime.now() - start)
<9>:<add> output = _get_user(user)
|
# module: backend.src.db.functions.get
def get_user_by_access_token(access_token: str) -> Optional[UserModel]:
<0> start = datetime.now()
<1> user: Optional[Dict[str, Any]] = await USERS.find_one( # type: ignore
<2> {"access_token": access_token}
<3> )
<4> if user is None:
<5> return None
<6> output = UserModel.parse_obj(user)
<7>
<8> print("MongoDB User Query:", datetime.now() - start)
<9> return output
<10>
|
===========unchanged ref 0===========
at: backend.src.db.functions.get
_get_user(user: Optional[Dict[str, Any]]) -> Optional[UserModel]
at: src.db.mongodb
USERS = DB.users # type: ignore
at: typing
Dict = _alias(dict, 2, inst=False, name='Dict')
===========changed ref 0===========
# module: backend.src.db.functions.get
+ def _get_user(user: Optional[Dict[str, Any]]) -> Optional[UserModel]:
+ if user is None:
+ return None
+
+ if "raw_data" not in user:
+ return UserModel.parse_obj(user)
+
+ raw_data = decompress(user["raw_data"])
+ return UserModel.parse_obj({**user, "raw_data": raw_data})
+
===========changed ref 1===========
# module: backend.src.db.functions.get
+ def _get_user(user: Optional[Dict[str, Any]]) -> Optional[UserModel]:
+ if user is None:
+ return None
+
+ if "raw_data" not in user:
+ return UserModel.parse_obj(user)
+
+ raw_data = decompress(user["raw_data"])
+ return UserModel.parse_obj({**user, "raw_data": raw_data})
+
===========changed ref 2===========
# module: backend.src.routers.pubsub
@router.post("/sub/user/{token}", status_code=status.HTTP_200_OK)
@pubsub_fail_gracefully
async def sub_user(response: Response, token: str, request: Request) -> Any:
data: Dict[str, Any] = await parse_request(token, request)
await lock_user(data["user_id"])
# standard policy is to check past five years of data
start_date = date.today() - timedelta(365 * 5)
end_date = date.today()
timezone_str = "US/Eastern"
# TODO: historical data is never updated,
# don't query full five years each time, instead
# define function to build on previous results
output = await get_data(
data["user_id"],
data["access_token"],
start_date,
end_date,
timezone_str,
)
+ await update_user(data["user_id"], output)
- await update_user(data["user_id"], output.dict())
await unlock_user(data["user_id"])
return data
|
backend.tests.external.github_api.graphql.test_user/TestTemplate.test_get_user_contribution_calendar
|
Modified
|
avgupta456~github-trends
|
4b9019e03636082be53a16b40fb9c72996537b54
|
implement compression
|
<0>:<add> response = get_user_contribution_calendar(
<add> user_id=USER_ID,
<add> access_token=TOKEN,
<add> start_date=datetime.today() - timedelta(days=365),
<add> end_date=datetime.today(),
<add> )
<del> response = get_user_contribution_calendar(user_id=USER_ID, access_token=TOKEN)
|
# module: backend.tests.external.github_api.graphql.test_user
class TestTemplate(unittest.TestCase):
def test_get_user_contribution_calendar(self):
<0> response = get_user_contribution_calendar(user_id=USER_ID, access_token=TOKEN)
<1> self.assertIsInstance(response, RawCalendar)
<2>
|
===========changed ref 0===========
# module: backend.src.db.functions.get
+ def _get_user(user: Optional[Dict[str, Any]]) -> Optional[UserModel]:
+ if user is None:
+ return None
+
+ if "raw_data" not in user:
+ return UserModel.parse_obj(user)
+
+ raw_data = decompress(user["raw_data"])
+ return UserModel.parse_obj({**user, "raw_data": raw_data})
+
===========changed ref 1===========
# module: backend.src.db.functions.get
+ def _get_user(user: Optional[Dict[str, Any]]) -> Optional[UserModel]:
+ if user is None:
+ return None
+
+ if "raw_data" not in user:
+ return UserModel.parse_obj(user)
+
+ raw_data = decompress(user["raw_data"])
+ return UserModel.parse_obj({**user, "raw_data": raw_data})
+
===========changed ref 2===========
# module: backend.src.db.functions.get
def get_user_by_access_token(access_token: str) -> Optional[UserModel]:
- start = datetime.now()
user: Optional[Dict[str, Any]] = await USERS.find_one( # type: ignore
{"access_token": access_token}
)
- if user is None:
- return None
- output = UserModel.parse_obj(user)
-
- print("MongoDB User Query:", datetime.now() - start)
+ output = _get_user(user)
return output
===========changed ref 3===========
# module: backend.src.routers.pubsub
@router.post("/sub/user/{token}", status_code=status.HTTP_200_OK)
@pubsub_fail_gracefully
async def sub_user(response: Response, token: str, request: Request) -> Any:
data: Dict[str, Any] = await parse_request(token, request)
await lock_user(data["user_id"])
# standard policy is to check past five years of data
start_date = date.today() - timedelta(365 * 5)
end_date = date.today()
timezone_str = "US/Eastern"
# TODO: historical data is never updated,
# don't query full five years each time, instead
# define function to build on previous results
output = await get_data(
data["user_id"],
data["access_token"],
start_date,
end_date,
timezone_str,
)
+ await update_user(data["user_id"], output)
- await update_user(data["user_id"], output.dict())
await unlock_user(data["user_id"])
return data
|
backend.tests.external.github_api.graphql.test_user/TestTemplate.test_get_user_contribution_events
|
Modified
|
avgupta456~github-trends
|
4b9019e03636082be53a16b40fb9c72996537b54
|
implement compression
|
<0>:<add> response = get_user_contribution_events(
<add> user_id=USER_ID,
<add> access_token=TOKEN,
<add> start_date=datetime.today() - timedelta(days=365),
<add> end_date=datetime.today(),
<add> )
<del> response = get_user_contribution_events(user_id=USER_ID, access_token=TOKEN)
|
# module: backend.tests.external.github_api.graphql.test_user
class TestTemplate(unittest.TestCase):
def test_get_user_contribution_events(self):
<0> response = get_user_contribution_events(user_id=USER_ID, access_token=TOKEN)
<1> self.assertIsInstance(response, RawEvents)
<2>
|
===========changed ref 0===========
# module: backend.tests.external.github_api.graphql.test_user
class TestTemplate(unittest.TestCase):
def test_get_user_contribution_calendar(self):
+ response = get_user_contribution_calendar(
+ user_id=USER_ID,
+ access_token=TOKEN,
+ start_date=datetime.today() - timedelta(days=365),
+ end_date=datetime.today(),
+ )
- response = get_user_contribution_calendar(user_id=USER_ID, access_token=TOKEN)
self.assertIsInstance(response, RawCalendar)
===========changed ref 1===========
# module: backend.src.db.functions.get
+ def _get_user(user: Optional[Dict[str, Any]]) -> Optional[UserModel]:
+ if user is None:
+ return None
+
+ if "raw_data" not in user:
+ return UserModel.parse_obj(user)
+
+ raw_data = decompress(user["raw_data"])
+ return UserModel.parse_obj({**user, "raw_data": raw_data})
+
===========changed ref 2===========
# module: backend.src.db.functions.get
+ def _get_user(user: Optional[Dict[str, Any]]) -> Optional[UserModel]:
+ if user is None:
+ return None
+
+ if "raw_data" not in user:
+ return UserModel.parse_obj(user)
+
+ raw_data = decompress(user["raw_data"])
+ return UserModel.parse_obj({**user, "raw_data": raw_data})
+
===========changed ref 3===========
# module: backend.src.db.functions.get
def get_user_by_access_token(access_token: str) -> Optional[UserModel]:
- start = datetime.now()
user: Optional[Dict[str, Any]] = await USERS.find_one( # type: ignore
{"access_token": access_token}
)
- if user is None:
- return None
- output = UserModel.parse_obj(user)
-
- print("MongoDB User Query:", datetime.now() - start)
+ output = _get_user(user)
return output
===========changed ref 4===========
# module: backend.src.routers.pubsub
@router.post("/sub/user/{token}", status_code=status.HTTP_200_OK)
@pubsub_fail_gracefully
async def sub_user(response: Response, token: str, request: Request) -> Any:
data: Dict[str, Any] = await parse_request(token, request)
await lock_user(data["user_id"])
# standard policy is to check past five years of data
start_date = date.today() - timedelta(365 * 5)
end_date = date.today()
timezone_str = "US/Eastern"
# TODO: historical data is never updated,
# don't query full five years each time, instead
# define function to build on previous results
output = await get_data(
data["user_id"],
data["access_token"],
start_date,
end_date,
timezone_str,
)
+ await update_user(data["user_id"], output)
- await update_user(data["user_id"], output.dict())
await unlock_user(data["user_id"])
return data
|
backend.src.db.functions.users/update_user
|
Modified
|
avgupta456~github-trends
|
4b9019e03636082be53a16b40fb9c72996537b54
|
implement compression
|
<1>:<add> compressed_data = compress(raw_data.dict())
<3>:<add> {"$set": {"last_updated": datetime.now(), "raw_data": compressed_data}},
<del> {"$set": {"last_updated": datetime.now(), "raw_data": raw_data}},
|
# module: backend.src.db.functions.users
+ def update_user(user_id: str, raw_data: Optional[UserPackage] = None) -> None:
- def update_user(user_id: str, raw_data: Optional[Dict[str, Any]] = None) -> None:
<0> if raw_data is not None:
<1> await USERS.update_one( # type: ignore
<2> {"user_id": user_id},
<3> {"$set": {"last_updated": datetime.now(), "raw_data": raw_data}},
<4> )
<5>
|
===========unchanged ref 0===========
at: src.db.functions.compression
compress(data: Dict[str, Any]) -> Dict[str, Any]
at: src.db.mongodb
USERS = DB.users # type: ignore
===========changed ref 0===========
# module: backend.src.db.functions.get
+ def _get_user(user: Optional[Dict[str, Any]]) -> Optional[UserModel]:
+ if user is None:
+ return None
+
+ if "raw_data" not in user:
+ return UserModel.parse_obj(user)
+
+ raw_data = decompress(user["raw_data"])
+ return UserModel.parse_obj({**user, "raw_data": raw_data})
+
===========changed ref 1===========
# module: backend.src.db.functions.get
+ def _get_user(user: Optional[Dict[str, Any]]) -> Optional[UserModel]:
+ if user is None:
+ return None
+
+ if "raw_data" not in user:
+ return UserModel.parse_obj(user)
+
+ raw_data = decompress(user["raw_data"])
+ return UserModel.parse_obj({**user, "raw_data": raw_data})
+
===========changed ref 2===========
# module: backend.tests.external.github_api.graphql.test_user
class TestTemplate(unittest.TestCase):
def test_get_user_contribution_events(self):
+ response = get_user_contribution_events(
+ user_id=USER_ID,
+ access_token=TOKEN,
+ start_date=datetime.today() - timedelta(days=365),
+ end_date=datetime.today(),
+ )
- response = get_user_contribution_events(user_id=USER_ID, access_token=TOKEN)
self.assertIsInstance(response, RawEvents)
===========changed ref 3===========
# module: backend.tests.external.github_api.graphql.test_user
class TestTemplate(unittest.TestCase):
def test_get_user_contribution_calendar(self):
+ response = get_user_contribution_calendar(
+ user_id=USER_ID,
+ access_token=TOKEN,
+ start_date=datetime.today() - timedelta(days=365),
+ end_date=datetime.today(),
+ )
- response = get_user_contribution_calendar(user_id=USER_ID, access_token=TOKEN)
self.assertIsInstance(response, RawCalendar)
===========changed ref 4===========
# module: backend.src.db.functions.get
def get_user_by_access_token(access_token: str) -> Optional[UserModel]:
- start = datetime.now()
user: Optional[Dict[str, Any]] = await USERS.find_one( # type: ignore
{"access_token": access_token}
)
- if user is None:
- return None
- output = UserModel.parse_obj(user)
-
- print("MongoDB User Query:", datetime.now() - start)
+ output = _get_user(user)
return output
===========changed ref 5===========
# module: backend.src.routers.pubsub
@router.post("/sub/user/{token}", status_code=status.HTTP_200_OK)
@pubsub_fail_gracefully
async def sub_user(response: Response, token: str, request: Request) -> Any:
data: Dict[str, Any] = await parse_request(token, request)
await lock_user(data["user_id"])
# standard policy is to check past five years of data
start_date = date.today() - timedelta(365 * 5)
end_date = date.today()
timezone_str = "US/Eastern"
# TODO: historical data is never updated,
# don't query full five years each time, instead
# define function to build on previous results
output = await get_data(
data["user_id"],
data["access_token"],
start_date,
end_date,
timezone_str,
)
+ await update_user(data["user_id"], output)
- await update_user(data["user_id"], output.dict())
await unlock_user(data["user_id"])
return data
|
backend.src.routers.users/get_user_lang_svg
|
Modified
|
avgupta456~github-trends
|
4b9019e03636082be53a16b40fb9c72996537b54
|
implement compression
|
<4>:<add> out = get_top_langs_svg(processed, use_percent)
<del> return get_top_langs_svg(processed, use_percent)
<5>:<add> return out
|
<s> "/{user_id}/svg/langs", status_code=status.HTTP_200_OK, response_class=HTMLResponse
)
@svg_fail_gracefully
async def get_user_lang_svg(
response: Response,
user_id: str,
start_date: date = date.today() - timedelta(365),
end_date: date = date.today(),
timezone_str: str = "US/Eastern",
use_percent: bool = True,
) -> Any:
<0> output = await _get_user(user_id, start_date, end_date)
<1> if output is None:
<2> return get_loading_svg()
<3> processed = get_top_languages(output)
<4> return get_top_langs_svg(processed, use_percent)
<5>
|
===========unchanged ref 0===========
at: backend.src.routers.users
router = APIRouter()
_get_user(user_id: str, start_date: date, end_date: date) -> Optional[UserPackage]
at: datetime
timedelta(days: float=..., seconds: float=..., microseconds: float=..., milliseconds: float=..., minutes: float=..., hours: float=..., weeks: float=..., *, fold: int=...)
date()
at: datetime.date
__slots__ = '_year', '_month', '_day', '_hashcode'
today() -> _S
__str__ = isoformat
__radd__ = __add__
at: src.analytics.user.commits
get_top_languages(data: UserPackage) -> List[LanguageStats]
at: src.svg.error
get_loading_svg() -> Drawing
at: src.svg.top_langs
get_top_langs_svg(data: List[LanguageStats], use_percent: bool=True) -> Drawing
at: src.utils
svg_fail_gracefully(func: Callable[..., Any])
===========changed ref 0===========
+ # module: backend.src.db.functions.compression
+
+
===========changed ref 1===========
# module: backend.src.db.functions.get
+ def _get_user(user: Optional[Dict[str, Any]]) -> Optional[UserModel]:
+ if user is None:
+ return None
+
+ if "raw_data" not in user:
+ return UserModel.parse_obj(user)
+
+ raw_data = decompress(user["raw_data"])
+ return UserModel.parse_obj({**user, "raw_data": raw_data})
+
===========changed ref 2===========
# module: backend.src.db.functions.get
+ def _get_user(user: Optional[Dict[str, Any]]) -> Optional[UserModel]:
+ if user is None:
+ return None
+
+ if "raw_data" not in user:
+ return UserModel.parse_obj(user)
+
+ raw_data = decompress(user["raw_data"])
+ return UserModel.parse_obj({**user, "raw_data": raw_data})
+
===========changed ref 3===========
# module: backend.src.db.functions.users
+ def update_user(user_id: str, raw_data: Optional[UserPackage] = None) -> None:
- def update_user(user_id: str, raw_data: Optional[Dict[str, Any]] = None) -> None:
if raw_data is not None:
+ compressed_data = compress(raw_data.dict())
await USERS.update_one( # type: ignore
{"user_id": user_id},
+ {"$set": {"last_updated": datetime.now(), "raw_data": compressed_data}},
- {"$set": {"last_updated": datetime.now(), "raw_data": raw_data}},
)
===========changed ref 4===========
# module: backend.tests.external.github_api.graphql.test_user
class TestTemplate(unittest.TestCase):
def test_get_user_contribution_events(self):
+ response = get_user_contribution_events(
+ user_id=USER_ID,
+ access_token=TOKEN,
+ start_date=datetime.today() - timedelta(days=365),
+ end_date=datetime.today(),
+ )
- response = get_user_contribution_events(user_id=USER_ID, access_token=TOKEN)
self.assertIsInstance(response, RawEvents)
===========changed ref 5===========
# module: backend.tests.external.github_api.graphql.test_user
class TestTemplate(unittest.TestCase):
def test_get_user_contribution_calendar(self):
+ response = get_user_contribution_calendar(
+ user_id=USER_ID,
+ access_token=TOKEN,
+ start_date=datetime.today() - timedelta(days=365),
+ end_date=datetime.today(),
+ )
- response = get_user_contribution_calendar(user_id=USER_ID, access_token=TOKEN)
self.assertIsInstance(response, RawCalendar)
===========changed ref 6===========
# module: backend.src.db.functions.get
def get_user_by_access_token(access_token: str) -> Optional[UserModel]:
- start = datetime.now()
user: Optional[Dict[str, Any]] = await USERS.find_one( # type: ignore
{"access_token": access_token}
)
- if user is None:
- return None
- output = UserModel.parse_obj(user)
-
- print("MongoDB User Query:", datetime.now() - start)
+ output = _get_user(user)
return output
===========changed ref 7===========
+ # module: backend.src.db.functions.compression
+ def compress_stats(data: Dict[str, Any]) -> Dict[str, Any]:
+ return {
+ "counts": (
+ data["contribs_count"],
+ data["commits_count"],
+ data["issues_count"],
+ data["prs_count"],
+ data["reviews_count"],
+ data["repos_count"],
+ data["other_count"],
+ ),
+ "languages": [
+ (name, stats["color"], stats["additions"], stats["deletions"])
+ for name, stats in data["languages"].items()
+ ],
+ }
+
===========changed ref 8===========
+ # module: backend.src.db.functions.compression
+ def decompress_stats(data: Dict[str, Any]) -> Dict[str, Any]:
+ return {
+ "contribs_count": data["counts"][0],
+ "commits_count": data["counts"][1],
+ "issues_count": data["counts"][2],
+ "prs_count": data["counts"][3],
+ "reviews_count": data["counts"][4],
+ "repos_count": data["counts"][5],
+ "other_count": data["counts"][6],
+ "languages": {
+ x[0]: {"color": x[1], "additions": x[2], "deletions": x[3]}
+ for x in data["languages"]
+ },
+ }
+
===========changed ref 9===========
# module: backend.src.routers.pubsub
@router.post("/sub/user/{token}", status_code=status.HTTP_200_OK)
@pubsub_fail_gracefully
async def sub_user(response: Response, token: str, request: Request) -> Any:
data: Dict[str, Any] = await parse_request(token, request)
await lock_user(data["user_id"])
# standard policy is to check past five years of data
start_date = date.today() - timedelta(365 * 5)
end_date = date.today()
timezone_str = "US/Eastern"
# TODO: historical data is never updated,
# don't query full five years each time, instead
# define function to build on previous results
output = await get_data(
data["user_id"],
data["access_token"],
start_date,
end_date,
timezone_str,
)
+ await update_user(data["user_id"], output)
- await update_user(data["user_id"], output.dict())
await unlock_user(data["user_id"])
return data
|
backend.src.db.functions.get/get_user_by_user_id
|
Modified
|
avgupta456~github-trends
|
4eb7cceb7a30854dbf48dce7950c58343d13152d
|
implement cache on mongodb gets
|
<1>:<del> output = _get_user(user)
<2>:<del> return output
|
# module: backend.src.db.functions.get
+ @alru_cache(max_size=128)
+ async def get_user_by_user_id(user_id: str) -> Optional[UserModel]:
- def get_user_by_user_id(user_id: str) -> Optional[UserModel]:
<0> user: Optional[Dict[str, Any]] = await USERS.find_one({"user_id": user_id}) # type: ignore
<1> output = _get_user(user)
<2> return output
<3>
|
===========unchanged ref 0===========
at: backend.src.db.functions.get.get_user_by_user_id
user: Optional[Dict[str, Any]] = await USERS.find_one({"user_id": user_id}) # type: ignore
===========changed ref 0===========
# module: backend.src.db.functions.get
- def _get_user(user: Optional[Dict[str, Any]]) -> Optional[UserModel]:
- if user is None:
- return None
-
- if "raw_data" not in user:
- return UserModel.parse_obj(user)
-
- raw_data = decompress(user["raw_data"])
- return UserModel.parse_obj({**user, "raw_data": raw_data})
-
|
backend.src.db.functions.get/get_user_by_access_token
|
Modified
|
avgupta456~github-trends
|
4eb7cceb7a30854dbf48dce7950c58343d13152d
|
implement cache on mongodb gets
|
<3>:<del> output = _get_user(user)
<4>:<del> return output
|
# module: backend.src.db.functions.get
+ @alru_cache(max_size=128)
+ async def get_user_by_access_token(access_token: str) -> Optional[UserModel]:
- def get_user_by_access_token(access_token: str) -> Optional[UserModel]:
<0> user: Optional[Dict[str, Any]] = await USERS.find_one( # type: ignore
<1> {"access_token": access_token}
<2> )
<3> output = _get_user(user)
<4> return output
<5>
|
===========unchanged ref 0===========
at: backend.src.db.functions.get.get_user_by_user_id
user: Optional[Dict[str, Any]] = await USERS.find_one({"user_id": user_id}) # type: ignore
raw_data = decompress(user["raw_data"])
at: src.helper.alru_cache
alru_cache(max_size: int=128, ttl: timedelta=timedelta(hours=1))
===========changed ref 0===========
# module: backend.src.db.functions.get
+ @alru_cache(max_size=128)
+ async def get_user_by_user_id(user_id: str) -> Optional[UserModel]:
- def get_user_by_user_id(user_id: str) -> Optional[UserModel]:
user: Optional[Dict[str, Any]] = await USERS.find_one({"user_id": user_id}) # type: ignore
- output = _get_user(user)
- return output
===========changed ref 1===========
# module: backend.src.db.functions.get
- def _get_user(user: Optional[Dict[str, Any]]) -> Optional[UserModel]:
- if user is None:
- return None
-
- if "raw_data" not in user:
- return UserModel.parse_obj(user)
-
- raw_data = decompress(user["raw_data"])
- return UserModel.parse_obj({**user, "raw_data": raw_data})
-
|
backend.src.svg.top_repos/get_top_repos_svg
|
Modified
|
avgupta456~github-trends
|
941eaec61339692f7684d360a3f42e8174ffa227
|
add time range to cards
|
<14>:<add> d.add(d.text(time_str, insert=(25, 55), class_="subheader"))
<15>:<add> repos = Group(transform="translate(25, 75)")
<del> repos = Group(transform="translate(25, 55)")
|
# module: backend.src.svg.top_repos
+ def get_top_repos_svg(data: List[RepoStats], time_str: str) -> Drawing:
- def get_top_repos_svg(data: List[RepoStats]) -> Drawing:
<0> d = Drawing(size=(300, 285))
<1> d.defs.add(d.style(style))
<2>
<3> d.add(
<4> d.rect(
<5> size=(299, 284),
<6> insert=(0.5, 0.5),
<7> rx=4.5,
<8> stroke="#e4e2e2",
<9> fill="#fffefe",
<10> )
<11> )
<12>
<13> d.add(d.text("Most Contributed Repositories", insert=(25, 35), class_="header"))
<14>
<15> repos = Group(transform="translate(25, 55)")
<16> for i in range(min(5, len(data))):
<17> translate = "translate(0, " + str(40 * i) + ")"
<18> total = data[0].changed
<19> repo = Group(transform=translate)
<20> repo.add(d.text(data[i].repo, insert=(2, 15), class_="lang-name"))
<21> repo.add(
<22> d.text(format_number(data[i].changed), insert=(215, 33), class_="lang-name")
<23> )
<24> progress = Drawing(width="205", x="0", y="25")
<25> progress.add(d.rect(size=(205, 8), insert=(0, 0), rx=5, ry=5, fill="#ddd"))
<26> total_percent = 0
<27> for j, lang in enumerate(data[i].langs):
<28> percent, color = 100 * (lang.additions + lang.deletions) / total, lang.color
<29> box_size, box_insert = (2.05 * percent, 8), (2.05 * total_percent, 0)
<30> progress.add(
<31> d.rect(size=box_size,</s>
|
===========below chunk 0===========
# module: backend.src.svg.top_repos
+ def get_top_repos_svg(data: List[RepoStats], time_str: str) -> Drawing:
- def get_top_repos_svg(data: List[RepoStats]) -> Drawing:
# offset: 1
)
box_left, box_right = j > 0, j < len(data[i].langs) - 1
box_size = 2.05 * percent - (0 if box_left else 5) - (0 if box_right else 5)
box_insert = 2.05 * total_percent + (5 if not box_left else 0)
progress.add(
d.rect(size=(max(box_size, 3), 8), insert=(box_insert, 0), fill=color)
)
total_percent += percent
repo.add(progress)
repos.add(repo)
d.add(repos)
return d
===========unchanged ref 0===========
at: backend.src.svg.top_repos
format_number(num: int) -> str
at: src.models.user.analytics.RepoLanguage
lang: str
color: str
additions: int
deletions: int
at: src.models.user.analytics.RepoStats
repo: str
langs: List[RepoLanguage]
additions: int
deletions: int
added: int
changed: int
at: src.svg.style
style = """
.header {
font: 600 18px 'Segoe UI', Ubuntu, Sans-Serif;
fill: #2f80ed;
animation: fadeInAnimation 0.8s ease-in-out forwards;
}
.subheader {
font: 500 14px 'Segoe UI', Ubuntu, San-Serif;
fill: #888;
}
.lang-name {
font: 400 11px 'Segoe UI', Ubuntu, Sans-Serif;
fill: #333;
}
@keyframes fadeInAnimation {
from {
opacity: 0;
}
to {
opacity: 1;
}
}
"""
at: typing
List = _alias(list, 1, inst=False, name='List')
|
backend.src.svg.top_langs/get_top_langs_svg
|
Modified
|
avgupta456~github-trends
|
941eaec61339692f7684d360a3f42e8174ffa227
|
add time range to cards
|
<14>:<add> d.add(d.text(time_str, insert=(25, 55), class_="subheader"))
<15>:<add> langs = Group(transform="translate(25, 75)")
<del> langs = Group(transform="translate(25, 55)")
|
# module: backend.src.svg.top_langs
+ def get_top_langs_svg(
+ data: List[LanguageStats], time_str: str, use_percent: bool = True
+ ) -> Drawing:
- def get_top_langs_svg(data: List[LanguageStats], use_percent: bool = True) -> Drawing:
<0> d = Drawing(size=(300, 285))
<1> d.defs.add(d.style(style))
<2>
<3> d.add(
<4> d.rect(
<5> size=(299, 284),
<6> insert=(0.5, 0.5),
<7> rx=4.5,
<8> stroke="#e4e2e2",
<9> fill="#fffefe",
<10> )
<11> )
<12>
<13> d.add(d.text("Most Used Languages", insert=(25, 35), class_="header"))
<14>
<15> langs = Group(transform="translate(25, 55)")
<16>
<17> data_langs = data[1:] # exclude "Total"
<18> for i in range(min(5, len(data_langs))):
<19> translate = "translate(0, " + str(40 * i) + ")"
<20> percent = (
<21> data_langs[i].percent
<22> if use_percent
<23> else 100 * data_langs[i].changed / data_langs[0].changed
<24> )
<25> color = data_langs[i].color or "#ededed"
<26> lang = Group(transform=translate)
<27> lang.add(d.text(data_langs[i].lang, insert=(2, 15), class_="lang-name"))
<28> if use_percent:
<29> lang.add(d.text(str(percent) + "%", insert=(215, 33), class_="lang-name"))
<30> else:
<31> lang.add(
<32> d.text(
<33> format_number(data_langs[i].changed),
<34> insert=(215, 33),
<35> class_="</s>
|
===========below chunk 0===========
# module: backend.src.svg.top_langs
+ def get_top_langs_svg(
+ data: List[LanguageStats], time_str: str, use_percent: bool = True
+ ) -> Drawing:
- def get_top_langs_svg(data: List[LanguageStats], use_percent: bool = True) -> Drawing:
# offset: 1
)
)
progress = Drawing(width="205", x="0", y="25")
progress.add(d.rect(size=(205, 8), insert=(0, 0), rx=5, ry=5, fill="#ddd"))
progress.add(
d.rect(
size=(2.05 * percent, 8),
insert=(0, 0),
rx=5,
ry=5,
fill=color,
)
)
lang.add(progress)
langs.add(lang)
d.add(langs)
return d
===========unchanged ref 0===========
at: backend.src.svg.top_langs
format_number(num: int) -> str
at: src.models.user.analytics.LanguageStats
lang: str
additions: int
deletions: int
added: int
changed: int
percent: float
color: Optional[str]
at: src.svg.style
style = """
.header {
font: 600 18px 'Segoe UI', Ubuntu, Sans-Serif;
fill: #2f80ed;
animation: fadeInAnimation 0.8s ease-in-out forwards;
}
.subheader {
font: 500 14px 'Segoe UI', Ubuntu, San-Serif;
fill: #888;
}
.lang-name {
font: 400 11px 'Segoe UI', Ubuntu, Sans-Serif;
fill: #333;
}
@keyframes fadeInAnimation {
from {
opacity: 0;
}
to {
opacity: 1;
}
}
"""
at: typing
List = _alias(list, 1, inst=False, name='List')
===========changed ref 0===========
# module: backend.src.svg.style
style = """
.header {
font: 600 18px 'Segoe UI', Ubuntu, Sans-Serif;
fill: #2f80ed;
animation: fadeInAnimation 0.8s ease-in-out forwards;
+ }
+ .subheader {
+ font: 500 14px 'Segoe UI', Ubuntu, San-Serif;
+ fill: #888;
}
.lang-name {
font: 400 11px 'Segoe UI', Ubuntu, Sans-Serif;
fill: #333;
}
@keyframes fadeInAnimation {
from {
opacity: 0;
}
to {
opacity: 1;
}
}
"""
===========changed ref 1===========
# module: backend.src.utils
+ # returns start date, end date, string representing time range
+ def use_time_range(
+ time_range: str, start_date: date, end_date: date
+ ) -> Tuple[date, date, str]:
+ duration_options = {
+ "one_month": (30, "Past 1 Month"),
+ "six_months": (180, "Past 6 Months"),
+ "one_year": (365, "Past 1 Year"),
+ "five_years": (365 * 5, "Past 5 Years"),
+ }
+
+ start_str = start_date.strftime("X%m/X%d/%Y").replace("X0", "X").replace("X", "")
+ end_str = end_date.strftime("X%m/X%d/%Y").replace("X0", "X").replace("X", "")
+ if end_date == date.today():
+ end_str = "Present"
+ time_str = start_str + " - " + end_str
+
+ if time_range in duration_options:
+ days, time_str = duration_options[time_range]
+ end_date = date.today()
+ start_date = date.today() - timedelta(days)
+
+ return start_date, end_date, time_str
+
===========changed ref 2===========
# module: backend.src.svg.top_repos
+ def get_top_repos_svg(data: List[RepoStats], time_str: str) -> Drawing:
- def get_top_repos_svg(data: List[RepoStats]) -> Drawing:
d = Drawing(size=(300, 285))
d.defs.add(d.style(style))
d.add(
d.rect(
size=(299, 284),
insert=(0.5, 0.5),
rx=4.5,
stroke="#e4e2e2",
fill="#fffefe",
)
)
d.add(d.text("Most Contributed Repositories", insert=(25, 35), class_="header"))
+ d.add(d.text(time_str, insert=(25, 55), class_="subheader"))
+ repos = Group(transform="translate(25, 75)")
- repos = Group(transform="translate(25, 55)")
for i in range(min(5, len(data))):
translate = "translate(0, " + str(40 * i) + ")"
total = data[0].changed
repo = Group(transform=translate)
repo.add(d.text(data[i].repo, insert=(2, 15), class_="lang-name"))
repo.add(
d.text(format_number(data[i].changed), insert=(215, 33), class_="lang-name")
)
progress = Drawing(width="205", x="0", y="25")
progress.add(d.rect(size=(205, 8), insert=(0, 0), rx=5, ry=5, fill="#ddd"))
total_percent = 0
for j, lang in enumerate(data[i].langs):
percent, color = 100 * (lang.additions + lang.deletions) / total, lang.color
box_size, box_insert = (2.05 * percent, 8), (2.05 * total_percent, 0)
progress.add</s>
===========changed ref 3===========
# module: backend.src.svg.top_repos
+ def get_top_repos_svg(data: List[RepoStats], time_str: str) -> Drawing:
- def get_top_repos_svg(data: List[RepoStats]) -> Drawing:
# offset: 1
<s>, box_insert = (2.05 * percent, 8), (2.05 * total_percent, 0)
progress.add(
d.rect(size=box_size, insert=box_insert, rx=5, ry=5, fill=color)
)
box_left, box_right = j > 0, j < len(data[i].langs) - 1
box_size = 2.05 * percent - (0 if box_left else 5) - (0 if box_right else 5)
box_insert = 2.05 * total_percent + (5 if not box_left else 0)
progress.add(
d.rect(size=(max(box_size, 3), 8), insert=(box_insert, 0), fill=color)
)
total_percent += percent
repo.add(progress)
repos.add(repo)
d.add(repos)
return d
|
backend.src.svg.top_repos/get_top_repos_svg
|
Modified
|
avgupta456~github-trends
|
f558c839c5a09448be6b2678df9d8f8a1acb113c
|
use templates
|
<0>:<del> d = Drawing(size=(300, 285))
<1>:<del> d.defs.add(d.style(style))
<2>:<del>
<3>:<del> d.add(
<4>:<del> d.rect(
<5>:<del> size=(299, 284),
<6>:<del> insert=(0.5, 0.5),
<7>:<del> rx=4.5,
<8>:<del> stroke="#e4e2e2",
<9>:<del> fill="#fffefe",
<10>:<del> )
<11>:<add> d, dp = get_template(
<add> width=300,
<add> height=285,
<add> padding=20,
<add> header_text="Most Contributed Repositories",
<add> subheader_text=time_str,
<add> debug=False,
<13>:<add> dataset: List[Tuple[str, str, List[Tuple[float, str]]]] = []
<add> total = data[0].changed
<add> for x in data[:5]:
<add> data_row = []
<add> for j, lang in enumerate(x.langs):
<add> data_row.append(
<add> (100 * (lang.additions + lang.deletions) / total, lang.color)
<add> )
<add> dataset.append((x.repo, format_number(x.changed), data_row))
<del> d.add(d.text("Most Contributed Repositories", insert=(25, 35), class_="header"))
<14>:<del> d.add(d.text(time_str, insert=(25, 55), class_="subheader"))
<16>:<del> repos = Group(transform="translate(25, 75)")
<17>:<del> for i in range(min(5, len(data))):
<18>:<del> translate = "translate(0, " + str(40 * i) + ")"
<19>:<del> total = data[0].changed
<20>:<del> repo = Group(transform=translate)
<21>:<del> repo.add(d.text(data[i].repo, insert=(2, 15), class_="lang-name"))
<22>:<del> repo.add(
<23>:<del> d.text(format_number(data[i].changed), insert=(215, 33), class_="lang-name")
<24>:<del> )
<25>:<del> progress = Drawing(width="205", x="0", y="25")
<26>:<del> progress.add(d.rect(size=(205, 8), insert=(0, 0), rx=5, ry=5, fill="#ddd"))
<27>:<del> total_percent = 0
<28>:<del> for j, lang in enumerate(data[i].langs):
<29>:<del> percent, color = 100 * (lang.additions + lang.deletions) / total, lang.color
<30>:<del> box_size, box_insert = (2.05 * percent, 8), (2.05 * total_percent, 0)
<31>:<del> progress.add(
<32>:<del> d.rect(size
|
# module: backend.src.svg.top_repos
def get_top_repos_svg(data: List[RepoStats], time_str: str) -> Drawing:
<0> d = Drawing(size=(300, 285))
<1> d.defs.add(d.style(style))
<2>
<3> d.add(
<4> d.rect(
<5> size=(299, 284),
<6> insert=(0.5, 0.5),
<7> rx=4.5,
<8> stroke="#e4e2e2",
<9> fill="#fffefe",
<10> )
<11> )
<12>
<13> d.add(d.text("Most Contributed Repositories", insert=(25, 35), class_="header"))
<14> d.add(d.text(time_str, insert=(25, 55), class_="subheader"))
<15>
<16> repos = Group(transform="translate(25, 75)")
<17> for i in range(min(5, len(data))):
<18> translate = "translate(0, " + str(40 * i) + ")"
<19> total = data[0].changed
<20> repo = Group(transform=translate)
<21> repo.add(d.text(data[i].repo, insert=(2, 15), class_="lang-name"))
<22> repo.add(
<23> d.text(format_number(data[i].changed), insert=(215, 33), class_="lang-name")
<24> )
<25> progress = Drawing(width="205", x="0", y="25")
<26> progress.add(d.rect(size=(205, 8), insert=(0, 0), rx=5, ry=5, fill="#ddd"))
<27> total_percent = 0
<28> for j, lang in enumerate(data[i].langs):
<29> percent, color = 100 * (lang.additions + lang.deletions) / total, lang.color
<30> box_size, box_insert = (2.05 * percent, 8), (2.05 * total_percent, 0)
<31> progress.add(
<32> d.rect(size</s>
|
===========below chunk 0===========
# module: backend.src.svg.top_repos
def get_top_repos_svg(data: List[RepoStats], time_str: str) -> Drawing:
# offset: 1
)
box_left, box_right = j > 0, j < len(data[i].langs) - 1
box_size = 2.05 * percent - (0 if box_left else 5) - (0 if box_right else 5)
box_insert = 2.05 * total_percent + (5 if not box_left else 0)
progress.add(
d.rect(size=(max(box_size, 3), 8), insert=(box_insert, 0), fill=color)
)
total_percent += percent
repo.add(progress)
repos.add(repo)
d.add(repos)
return d
===========unchanged ref 0===========
at: backend.src.svg.top_repos.get_top_repos_svg
d, dp = get_template(
width=300,
height=285,
padding=20,
header_text="Most Contributed Repositories",
subheader_text=time_str,
debug=False,
)
d, dp = get_template(
width=300,
height=285,
padding=20,
header_text="Most Contributed Repositories",
subheader_text=time_str,
debug=False,
)
dataset: List[Tuple[str, str, List[Tuple[float, str]]]] = []
total = data[0].changed
at: src.models.user.analytics.RepoLanguage
lang: str
color: str
additions: int
deletions: int
at: src.models.user.analytics.RepoStats
repo: str
langs: List[RepoLanguage]
additions: int
deletions: int
added: int
changed: int
at: src.svg.template
format_number(num: int) -> str
get_bar_section(d: Drawing, dataset: List[Tuple[str, str, List[Tuple[float, str]]]], padding: int=45, bar_width: int=210) -> Group
===========changed ref 0===========
# module: backend.src.svg.top_repos
- def format_number(num: int) -> str:
- if num > 10000:
- return "~" + str(int(num / 1000)) + "k lines"
- elif num > 1000:
- return "~" + str(int(num / 100) / 10) + "k lines"
- elif num > 100:
- return "~" + str(int(num / 100) * 100) + " lines"
- else:
- return "<100 lines"
-
|
backend.src.svg.top_langs/get_top_langs_svg
|
Modified
|
avgupta456~github-trends
|
f558c839c5a09448be6b2678df9d8f8a1acb113c
|
use templates
|
<0>:<del> d = Drawing(size=(300, 285))
<1>:<del> d.defs.add(d.style(style))
<2>:<del>
<3>:<del> d.add(
<4>:<del> d.rect(
<5>:<del> size=(299, 284),
<6>:<del> insert=(0.5, 0.5),
<7>:<del> rx=4.5,
<8>:<del> stroke="#e4e2e2",
<9>:<del> fill="#fffefe",
<10>:<del> )
<11>:<add> d, dp = get_template(
<add> width=300,
<add> height=285,
<add> padding=20,
<add> header_text="Most Used Languages",
<add> subheader_text=time_str,
<add> debug=False,
<13>:<add> dataset: List[Tuple[str, str, List[Tuple[float, str]]]] = []
<add> for x in data[1:6]:
<add> if use_percent:
<add> dataset.append((x.lang, str(x.percent) + "%", [(x.percent, x.color)]))
<add> else:
<add> percent = 100 * x.changed / data[1].changed
<add> dataset.append((x.lang, format_number(x.changed), [(percent, x.color)]))
<del> d.add(d.text("Most Used Languages", insert=(25, 35), class_="header"))
<14>:<del> d.add(d.text(time_str, insert=(25, 55), class_="subheader"))
<16>:<add> section = get_bar_section(
<add> d=d, dataset=dataset, padding=45, bar_width=210 if use_percent else 195
|
# module: backend.src.svg.top_langs
def get_top_langs_svg(
+ data: List[LanguageStats], time_str: str, use_percent: bool = False
- data: List[LanguageStats], time_str: str, use_percent: bool = True
) -> Drawing:
<0> d = Drawing(size=(300, 285))
<1> d.defs.add(d.style(style))
<2>
<3> d.add(
<4> d.rect(
<5> size=(299, 284),
<6> insert=(0.5, 0.5),
<7> rx=4.5,
<8> stroke="#e4e2e2",
<9> fill="#fffefe",
<10> )
<11> )
<12>
<13> d.add(d.text("Most Used Languages", insert=(25, 35), class_="header"))
<14> d.add(d.text(time_str, insert=(25, 55), class_="subheader"))
<15>
<16> langs = Group(transform="translate(25, 75)")
<17>
<18> data_langs = data[1:] # exclude "Total"
<19> for i in range(min(5, len(data_langs))):
<20> translate = "translate(0, " + str(40 * i) + ")"
<21> percent = (
<22> data_langs[i].percent
<23> if use_percent
<24> else 100 * data_langs[i].changed / data_langs[0].changed
<25> )
<26> color = data_langs[i].color or "#ededed"
<27> lang = Group(transform=translate)
<28> lang.add(d.text(data_langs[i].lang, insert=(2, 15), class_="lang-name"))
<29> if use_percent:
<30> lang.add(d.text(str(percent) + "%", insert=(215, 33), class_="lang-name"))
<31> else:
<32> lang.add(
<33> d.text(
<34> format_number(data_langs[i].</s>
|
===========below chunk 0===========
# module: backend.src.svg.top_langs
def get_top_langs_svg(
+ data: List[LanguageStats], time_str: str, use_percent: bool = False
- data: List[LanguageStats], time_str: str, use_percent: bool = True
) -> Drawing:
# offset: 1
insert=(215, 33),
class_="lang-name",
)
)
progress = Drawing(width="205", x="0", y="25")
progress.add(d.rect(size=(205, 8), insert=(0, 0), rx=5, ry=5, fill="#ddd"))
progress.add(
d.rect(
size=(2.05 * percent, 8),
insert=(0, 0),
rx=5,
ry=5,
fill=color,
)
)
lang.add(progress)
langs.add(lang)
d.add(langs)
return d
===========unchanged ref 0===========
at: backend.src.svg.top_langs.get_top_langs_svg
d, dp = get_template(
width=300,
height=285,
padding=20,
header_text="Most Used Languages",
subheader_text=time_str,
debug=False,
)
d, dp = get_template(
width=300,
height=285,
padding=20,
header_text="Most Used Languages",
subheader_text=time_str,
debug=False,
)
at: src.models.user.analytics.LanguageStats
lang: str
additions: int
deletions: int
added: int
changed: int
percent: float
color: Optional[str]
at: src.svg.template
format_number(num: int) -> str
get_bar_section(d: Drawing, dataset: List[Tuple[str, str, List[Tuple[float, str]]]], padding: int=45, bar_width: int=210) -> Group
at: typing
Tuple = _TupleType(tuple, -1, inst=False, name='Tuple')
List = _alias(list, 1, inst=False, name='List')
===========changed ref 0===========
# module: backend.src.svg.top_langs
- def format_number(num: int) -> str:
- if num > 10000:
- return "~" + str(int(num / 1000)) + "k lines"
- elif num > 1000:
- return "~" + str(int(num / 100) / 10) + "k lines"
- elif num > 100:
- return "~" + str(int(num / 100) * 100) + " lines"
- else:
- return "<100 lines"
-
===========changed ref 1===========
# module: backend.src.svg.top_repos
- def format_number(num: int) -> str:
- if num > 10000:
- return "~" + str(int(num / 1000)) + "k lines"
- elif num > 1000:
- return "~" + str(int(num / 100) / 10) + "k lines"
- elif num > 100:
- return "~" + str(int(num / 100) * 100) + " lines"
- else:
- return "<100 lines"
-
===========changed ref 2===========
# module: backend.src.svg.style
style = """
.header {
font: 600 18px 'Segoe UI', Ubuntu, Sans-Serif;
fill: #2f80ed;
animation: fadeInAnimation 0.8s ease-in-out forwards;
}
.subheader {
font: 500 14px 'Segoe UI', Ubuntu, San-Serif;
fill: #888;
+ animation: fadeInAnimation 0.8s ease-in-out forwards;
}
.lang-name {
font: 400 11px 'Segoe UI', Ubuntu, Sans-Serif;
fill: #333;
}
@keyframes fadeInAnimation {
from {
opacity: 0;
}
to {
opacity: 1;
}
}
"""
===========changed ref 3===========
# module: backend.src.svg.top_repos
def get_top_repos_svg(data: List[RepoStats], time_str: str) -> Drawing:
- d = Drawing(size=(300, 285))
- d.defs.add(d.style(style))
-
- d.add(
- d.rect(
- size=(299, 284),
- insert=(0.5, 0.5),
- rx=4.5,
- stroke="#e4e2e2",
- fill="#fffefe",
- )
+ d, dp = get_template(
+ width=300,
+ height=285,
+ padding=20,
+ header_text="Most Contributed Repositories",
+ subheader_text=time_str,
+ debug=False,
)
+ dataset: List[Tuple[str, str, List[Tuple[float, str]]]] = []
+ total = data[0].changed
+ for x in data[:5]:
+ data_row = []
+ for j, lang in enumerate(x.langs):
+ data_row.append(
+ (100 * (lang.additions + lang.deletions) / total, lang.color)
+ )
+ dataset.append((x.repo, format_number(x.changed), data_row))
- d.add(d.text("Most Contributed Repositories", insert=(25, 35), class_="header"))
- d.add(d.text(time_str, insert=(25, 55), class_="subheader"))
- repos = Group(transform="translate(25, 75)")
- for i in range(min(5, len(data))):
- translate = "translate(0, " + str(40 * i) + ")"
- total = data[0].changed
- repo = Group(transform=translate)
- repo.add(d.text(data[i].repo, insert=(2, 15), class_="lang-name"))
- repo.add(
- </s>
|
backend.src.svg.template/get_template
|
Modified
|
avgupta456~github-trends
|
bc459dd8cf51f75d94907d27260f5b3255d9f9db
|
styling
|
<24>:<add> dp.add(d.text(subheader_text, insert=(0, 33), class_="subheader"))
<del> dp.add(d.text(subheader_text, insert=(0, 35), class_="subheader"))
|
# module: backend.src.svg.template
def get_template(
width: int,
height: int,
padding: int,
header_text: str,
subheader_text: str,
debug: bool = False,
) -> Tuple[Drawing, Group]:
<0> d = Drawing(size=(width, height))
<1> d.defs.add(d.style(style))
<2>
<3> d.add(
<4> d.rect(
<5> size=(width - 1, height - 1),
<6> insert=(0.5, 0.5),
<7> rx=4.5,
<8> stroke="#e4e2e2",
<9> fill="#fffefe",
<10> )
<11> )
<12>
<13> d.add(
<14> d.rect(
<15> size=(width - 2 * padding, height - 2 * padding),
<16> insert=(padding, padding),
<17> fill="#eee" if debug else "#fff",
<18> )
<19> )
<20>
<21> dp = Group(transform="translate(" + str(padding) + ", " + str(padding) + ")")
<22>
<23> dp.add(d.text(header_text, insert=(0, 13), class_="header"))
<24> dp.add(d.text(subheader_text, insert=(0, 35), class_="subheader"))
<25>
<26> return d, dp
<27>
|
===========unchanged ref 0===========
at: src.svg.style
style = """
.header {
font: 600 18px 'Segoe UI', Ubuntu, Sans-Serif;
fill: #2f80ed;
animation: fadeInAnimation 0.8s ease-in-out forwards;
}
.subheader {
font: 500 13px 'Segoe UI', Ubuntu, San-Serif;
fill: #666;
animation: fadeInAnimation 0.8s ease-in-out forwards;
}
.lang-name {
font: 400 11px 'Segoe UI', Ubuntu, Sans-Serif;
fill: #333;
}
@keyframes fadeInAnimation {
from {
opacity: 0;
}
to {
opacity: 1;
}
}
"""
at: typing
Tuple = _TupleType(tuple, -1, inst=False, name='Tuple')
|
backend.src.db.functions.get/get_user_by_user_id
|
Modified
|
avgupta456~github-trends
|
1d5a6a416982fad5cdbe8eb15adcd1de49672886
|
add public contrib stats
|
<15>:<add> try:
<add> return (True, UserModel.parse_obj({**user, "raw_data": raw_data})) # type: ignore
<del> return (True, UserModel.parse_obj({**user, "raw_data": raw_data})) # type: ignore
<16>:<add> except ValidationError:
<add> return (False, UserModel.parse_obj({**user, "raw_data": None})) # type: ignore
|
# module: backend.src.db.functions.get
@alru_cache(max_size=128)
async def get_user_by_user_id(user_id: str) -> Optional[UserModel]:
<0> user: Optional[Dict[str, Any]] = await USERS.find_one({"user_id": user_id}) # type: ignore
<1>
<2> # (flag, value) output through decorator returns value
<3>
<4> if user is None:
<5> # flag is false, don't cache
<6> return (False, None) # type: ignore
<7>
<8> if "raw_data" not in user:
<9> # flag is false, don't cache
<10> return (False, UserModel.parse_obj(user)) # type: ignore
<11>
<12> raw_data = decompress(user["raw_data"])
<13>
<14> # flag is true, do cache
<15> return (True, UserModel.parse_obj({**user, "raw_data": raw_data})) # type: ignore
<16>
|
===========unchanged ref 0===========
at: src.db.functions.compression
decompress(data: Dict[str, Any]) -> Dict[str, Any]
at: src.db.mongodb
USERS = DB.users # type: ignore
at: src.helper.alru_cache
alru_cache(max_size: int=128, ttl: timedelta=timedelta(hours=1))
at: typing
Dict = _alias(dict, 2, inst=False, name='Dict')
|
backend.src.routers.users.dev/get_user_raw
|
Modified
|
avgupta456~github-trends
|
1d5a6a416982fad5cdbe8eb15adcd1de49672886
|
add public contrib stats
|
<4>:<add> start_date, end_date, _ = use_time_range(time_range, start_date, end_date)
|
<s>ers.users.dev
@router.get("/{user_id}", status_code=status.HTTP_200_OK)
@async_fail_gracefully
async def get_user_raw(
response: Response,
user_id: str,
start_date: date = date.today() - timedelta(365),
end_date: date = date.today(),
+ time_range: str = "one_month",
timezone_str: str = "US/Eastern",
) -> UserPackage:
<0> db_user = await get_user_by_user_id(user_id)
<1> if db_user is None or db_user.access_token == "":
<2> raise LookupError("Invalid UserId")
<3>
<4> data = await get_data(
<5> user_id, db_user.access_token, start_date, end_date, timezone_str
<6> )
<7>
<8> return data
<9>
|
===========unchanged ref 0===========
at: backend.src.routers.users.dev
router = APIRouter()
at: datetime
timedelta(days: float=..., seconds: float=..., microseconds: float=..., milliseconds: float=..., minutes: float=..., hours: float=..., weeks: float=..., *, fold: int=...)
date()
at: datetime.date
__slots__ = '_year', '_month', '_day', '_hashcode'
today() -> _S
__str__ = isoformat
__radd__ = __add__
at: src.db.functions.get
Callable(*args: List[Any], **kwargs: Dict[str, Any]) -> Any
at: src.packaging.user
main(user_id: str, access_token: str, start_date: date, end_date: date, timezone_str: str="US/Eastern") -> UserPackage
at: src.utils
async_fail_gracefully(func: Callable[..., Any])
use_time_range(time_range: str, start_date: date, end_date: date) -> Tuple[date, date, str]
===========changed ref 0===========
# module: backend.src.models.user.contribs
- class RepoContributionDay(BaseModel):
- date: str
- weekday: int
- stats: ContributionStats
-
===========changed ref 1===========
# module: backend.src.models.user.contribs
class ContributionDay(BaseModel):
date: str
weekday: int
stats: ContributionStats
- lists: ContributionLists
===========changed ref 2===========
# module: backend.src.models.user.contribs
+ # temporarily remove list from total to reduce storage
+ # TODO: improve compression so this is not necessary
+ # lists: ContributionLists
+
+
+ class RepoContributionStats(BaseModel):
+ private: bool
+ contribs_count: int
+ commits_count: int
+ issues_count: int
+ prs_count: int
+ reviews_count: int
+ repos_count: int
+ other_count: int
+ languages: Dict[str, Language]
+
===========changed ref 3===========
# module: backend.src.models.user.contribs
class UserContributions(BaseModel):
total_stats: ContributionStats
- # temporarily remove list from total to reduce storage
- # TODO: improve compression so this is not necessary
+ public_stats: ContributionStats
+ total: List[ContributionDay]
- total: List[RepoContributionDay]
+ public: List[ContributionDay]
+ repo_stats: Dict[str, RepoContributionStats]
- repo_stats: Dict[str, ContributionStats]
+ repos: Dict[str, List[ContributionDay]]
- repos: Dict[str, List[RepoContributionDay]]
===========changed ref 4===========
# module: backend.src.db.functions.get
@alru_cache(max_size=128)
async def get_user_by_user_id(user_id: str) -> Optional[UserModel]:
user: Optional[Dict[str, Any]] = await USERS.find_one({"user_id": user_id}) # type: ignore
# (flag, value) output through decorator returns value
if user is None:
# flag is false, don't cache
return (False, None) # type: ignore
if "raw_data" not in user:
# flag is false, don't cache
return (False, UserModel.parse_obj(user)) # type: ignore
raw_data = decompress(user["raw_data"])
# flag is true, do cache
+ try:
+ return (True, UserModel.parse_obj({**user, "raw_data": raw_data})) # type: ignore
- return (True, UserModel.parse_obj({**user, "raw_data": raw_data})) # type: ignore
+ except ValidationError:
+ return (False, UserModel.parse_obj({**user, "raw_data": None})) # type: ignore
===========changed ref 5===========
# module: backend.src.processing.user.contributions
def get_contributions(
user_id: str,
access_token: str,
start_date: date = date.today() - timedelta(365),
end_date: date = date.today(),
timezone_str: str = "US/Eastern",
) -> UserContributions:
tz = pytz.timezone(timezone_str)
# get years for contribution calendar
years = sorted(
filter(
lambda x: start_date.year <= x <= end_date.year,
get_user_contribution_years(user_id, access_token),
)
)
dates = [
[
date_to_datetime(max(date(year, 1, 1), start_date)),
date_to_datetime(
min(date(year, 12, 31), end_date), hour=23, minute=59, second=59
),
]
for year in years
]
# async get contribution calendars
calendars: List[RawCalendar] = await gather(
funcs=[get_user_contribution_calendar for _ in years],
args_dicts=[
{
"user_id": user_id,
"access_token": access_token,
"start_date": dates[i][0],
"end_date": dates[i][1],
}
for i in range(len(years))
],
)
all_events: List[t_stats] = await gather(
funcs=[get_user_all_contribution_events for _ in years],
args_dicts=[
{
"user_id": user_id,
"access_token": access_token,
"start_date": dates[i][0],
"end_date": dates[i][1],
}
for i in range(len(years))
],
)
repos_set: Set[str] = set()
for events_year in all_events:
for repo in events_year</s>
===========changed ref 6===========
# module: backend.src.processing.user.contributions
def get_contributions(
user_id: str,
access_token: str,
start_date: date = date.today() - timedelta(365),
end_date: date = date.today(),
timezone_str: str = "US/Eastern",
) -> UserContributions:
# offset: 1
<s> repos_set: Set[str] = set()
for events_year in all_events:
for repo in events_year:
repos_set.add(repo)
repos = list(repos_set)
commit_infos = await gather(
funcs=[get_all_commit_info for _ in repos],
args_dicts=[
{
"user_id": user_id,
"access_token": access_token,
"name_with_owner": repo,
"start_date": dates[0][0], # first start
"end_date": dates[-1][1], # last end
}
for repo in repos
],
max_threads=100,
)
_repo_infos = await gather(
funcs=[get_repo for _ in repos],
args_dicts=[
{
"access_token": access_token,
"owner": repo.split("/")[0],
"repo": repo.split("/")[1],
}
for repo in repos
],
max_threads=100,
)
- repo_infos = {
- repo: repo_info["languages"]["edges"]
- for repo, repo_info in zip(repos, _repo_infos)
- }
+ repo_infos = {repo: repo_info for repo, repo_info in zip(repos, _repo_infos)}
commit_times = [[x[0] for x in repo] for repo in commit_infos]
commit_node_ids = [[x[1] for</s>
|
backend.src.external.github_api.graphql.repo/get_repo
|
Modified
|
avgupta456~github-trends
|
1d5a6a416982fad5cdbe8eb15adcd1de49672886
|
add public contrib stats
|
<6>:<add> isPrivate,
|
# module: backend.src.external.github_api.graphql.repo
# TODO: create return class
def get_repo(
access_token: str, owner: str, repo: str
) -> Union[Dict[str, Any], List[Any]]:
<0> """gets all repository data from graphql"""
<1> query = {
<2> "variables": {"owner": owner, "repo": repo},
<3> "query": """
<4> query getRepo($owner: String!, $repo: String!) {
<5> repository(owner: $owner, name: $repo) {
<6> forkCount,
<7> stargazerCount,
<8> languages(first: 5){
<9> totalCount,
<10> totalSize,
<11> edges{
<12> node {
<13> name,
<14> color,
<15> },
<16> size,
<17> },
<18> },
<19> }
<20> }
<21> """,
<22> }
<23>
<24> return get_template(query, access_token)["data"]["repository"]
<25>
|
===========unchanged ref 0===========
at: typing
List = _alias(list, 1, inst=False, name='List')
Dict = _alias(dict, 2, inst=False, name='Dict')
===========changed ref 0===========
# module: backend.src.models.user.contribs
- class RepoContributionDay(BaseModel):
- date: str
- weekday: int
- stats: ContributionStats
-
===========changed ref 1===========
# module: backend.src.models.user.contribs
class ContributionDay(BaseModel):
date: str
weekday: int
stats: ContributionStats
- lists: ContributionLists
===========changed ref 2===========
# module: backend.src.models.user.contribs
+ # temporarily remove list from total to reduce storage
+ # TODO: improve compression so this is not necessary
+ # lists: ContributionLists
+
+
+ class RepoContributionStats(BaseModel):
+ private: bool
+ contribs_count: int
+ commits_count: int
+ issues_count: int
+ prs_count: int
+ reviews_count: int
+ repos_count: int
+ other_count: int
+ languages: Dict[str, Language]
+
===========changed ref 3===========
<s>ers.users.dev
@router.get("/{user_id}", status_code=status.HTTP_200_OK)
@async_fail_gracefully
async def get_user_raw(
response: Response,
user_id: str,
start_date: date = date.today() - timedelta(365),
end_date: date = date.today(),
+ time_range: str = "one_month",
timezone_str: str = "US/Eastern",
) -> UserPackage:
db_user = await get_user_by_user_id(user_id)
if db_user is None or db_user.access_token == "":
raise LookupError("Invalid UserId")
+ start_date, end_date, _ = use_time_range(time_range, start_date, end_date)
data = await get_data(
user_id, db_user.access_token, start_date, end_date, timezone_str
)
return data
===========changed ref 4===========
# module: backend.src.models.user.contribs
class UserContributions(BaseModel):
total_stats: ContributionStats
- # temporarily remove list from total to reduce storage
- # TODO: improve compression so this is not necessary
+ public_stats: ContributionStats
+ total: List[ContributionDay]
- total: List[RepoContributionDay]
+ public: List[ContributionDay]
+ repo_stats: Dict[str, RepoContributionStats]
- repo_stats: Dict[str, ContributionStats]
+ repos: Dict[str, List[ContributionDay]]
- repos: Dict[str, List[RepoContributionDay]]
===========changed ref 5===========
# module: backend.src.db.functions.get
@alru_cache(max_size=128)
async def get_user_by_user_id(user_id: str) -> Optional[UserModel]:
user: Optional[Dict[str, Any]] = await USERS.find_one({"user_id": user_id}) # type: ignore
# (flag, value) output through decorator returns value
if user is None:
# flag is false, don't cache
return (False, None) # type: ignore
if "raw_data" not in user:
# flag is false, don't cache
return (False, UserModel.parse_obj(user)) # type: ignore
raw_data = decompress(user["raw_data"])
# flag is true, do cache
+ try:
+ return (True, UserModel.parse_obj({**user, "raw_data": raw_data})) # type: ignore
- return (True, UserModel.parse_obj({**user, "raw_data": raw_data})) # type: ignore
+ except ValidationError:
+ return (False, UserModel.parse_obj({**user, "raw_data": None})) # type: ignore
===========changed ref 6===========
# module: backend.src.processing.user.contributions
def get_contributions(
user_id: str,
access_token: str,
start_date: date = date.today() - timedelta(365),
end_date: date = date.today(),
timezone_str: str = "US/Eastern",
) -> UserContributions:
tz = pytz.timezone(timezone_str)
# get years for contribution calendar
years = sorted(
filter(
lambda x: start_date.year <= x <= end_date.year,
get_user_contribution_years(user_id, access_token),
)
)
dates = [
[
date_to_datetime(max(date(year, 1, 1), start_date)),
date_to_datetime(
min(date(year, 12, 31), end_date), hour=23, minute=59, second=59
),
]
for year in years
]
# async get contribution calendars
calendars: List[RawCalendar] = await gather(
funcs=[get_user_contribution_calendar for _ in years],
args_dicts=[
{
"user_id": user_id,
"access_token": access_token,
"start_date": dates[i][0],
"end_date": dates[i][1],
}
for i in range(len(years))
],
)
all_events: List[t_stats] = await gather(
funcs=[get_user_all_contribution_events for _ in years],
args_dicts=[
{
"user_id": user_id,
"access_token": access_token,
"start_date": dates[i][0],
"end_date": dates[i][1],
}
for i in range(len(years))
],
)
repos_set: Set[str] = set()
for events_year in all_events:
for repo in events_year</s>
===========changed ref 7===========
# module: backend.src.processing.user.contributions
def get_contributions(
user_id: str,
access_token: str,
start_date: date = date.today() - timedelta(365),
end_date: date = date.today(),
timezone_str: str = "US/Eastern",
) -> UserContributions:
# offset: 1
<s> repos_set: Set[str] = set()
for events_year in all_events:
for repo in events_year:
repos_set.add(repo)
repos = list(repos_set)
commit_infos = await gather(
funcs=[get_all_commit_info for _ in repos],
args_dicts=[
{
"user_id": user_id,
"access_token": access_token,
"name_with_owner": repo,
"start_date": dates[0][0], # first start
"end_date": dates[-1][1], # last end
}
for repo in repos
],
max_threads=100,
)
_repo_infos = await gather(
funcs=[get_repo for _ in repos],
args_dicts=[
{
"access_token": access_token,
"owner": repo.split("/")[0],
"repo": repo.split("/")[1],
}
for repo in repos
],
max_threads=100,
)
- repo_infos = {
- repo: repo_info["languages"]["edges"]
- for repo, repo_info in zip(repos, _repo_infos)
- }
+ repo_infos = {repo: repo_info for repo, repo_info in zip(repos, _repo_infos)}
commit_times = [[x[0] for x in repo] for repo in commit_infos]
commit_node_ids = [[x[1] for</s>
|
backend.src.processing.user.commit/get_commits_languages
|
Modified
|
avgupta456~github-trends
|
1d5a6a416982fad5cdbe8eb15adcd1de49672886
|
add public contrib stats
|
<11>:<add> repo_info = repo_infos[commit_repo]["languages"]["edges"]
<del> repo_info = repo_infos[commit_repo]
|
# module: backend.src.processing.user.commit
def get_commits_languages(
access_token: str,
node_ids: List[str],
commit_repos: List[str],
repo_infos: Dict[str, Any],
cutoff: int = CUTOFF,
):
<0> all_data = _get_commits_languages(access_token, node_ids, per_page=NODE_CHUNK_SIZE)
<1>
<2> out: List[Dict[str, Dict[str, int]]] = []
<3> for commit, commit_repo in zip(all_data, commit_repos):
<4> out.append({})
<5> if (
<6> "additions" in commit
<7> and "deletions" in commit
<8> and "changedFiles" in commit
<9> and commit["additions"] + commit["deletions"] < cutoff
<10> ):
<11> repo_info = repo_infos[commit_repo]
<12> languages = [x for x in repo_info if x["node"]["name"] not in BLACKLIST]
<13> num_langs = min(len(languages), commit["changedFiles"])
<14> total_repo_size = sum(
<15> [language["size"] for language in languages[:num_langs]]
<16> )
<17> for language in languages[:num_langs]:
<18> lang_name = language["node"]["name"]
<19> lang_color = language["node"]["color"]
<20> additions = round(
<21> commit["additions"] * language["size"] / total_repo_size
<22> )
<23> deletions = round(
<24> commit["deletions"] * language["size"] / total_repo_size
<25> )
<26> if additions > 0 or deletions > 0:
<27> out[-1][lang_name] = {
<28> "additions": additions,
<29> "deletions": deletions,
<30> "color": lang_color,
<31> }
<32>
<33> return out
<34>
|
===========unchanged ref 0===========
at: backend.src.processing.user.commit
_get_commits_languages(access_token: str, node_ids: List[str], per_page: int=NODE_CHUNK_SIZE) -> List[Dict[str, Any]]
at: src.constants
NODE_CHUNK_SIZE = 40 # number of nodes (commits) to query (max 100)
CUTOFF = 500 # if > cutoff lines, assume imported, don't count
BLACKLIST = ["Jupyter Notebook", "HTML"] # languages to ignore
at: typing
List = _alias(list, 1, inst=False, name='List')
Dict = _alias(dict, 2, inst=False, name='Dict')
===========changed ref 0===========
# module: backend.src.models.user.contribs
- class RepoContributionDay(BaseModel):
- date: str
- weekday: int
- stats: ContributionStats
-
===========changed ref 1===========
# module: backend.src.models.user.contribs
class ContributionDay(BaseModel):
date: str
weekday: int
stats: ContributionStats
- lists: ContributionLists
===========changed ref 2===========
# module: backend.src.models.user.contribs
+ # temporarily remove list from total to reduce storage
+ # TODO: improve compression so this is not necessary
+ # lists: ContributionLists
+
+
+ class RepoContributionStats(BaseModel):
+ private: bool
+ contribs_count: int
+ commits_count: int
+ issues_count: int
+ prs_count: int
+ reviews_count: int
+ repos_count: int
+ other_count: int
+ languages: Dict[str, Language]
+
===========changed ref 3===========
<s>ers.users.dev
@router.get("/{user_id}", status_code=status.HTTP_200_OK)
@async_fail_gracefully
async def get_user_raw(
response: Response,
user_id: str,
start_date: date = date.today() - timedelta(365),
end_date: date = date.today(),
+ time_range: str = "one_month",
timezone_str: str = "US/Eastern",
) -> UserPackage:
db_user = await get_user_by_user_id(user_id)
if db_user is None or db_user.access_token == "":
raise LookupError("Invalid UserId")
+ start_date, end_date, _ = use_time_range(time_range, start_date, end_date)
data = await get_data(
user_id, db_user.access_token, start_date, end_date, timezone_str
)
return data
===========changed ref 4===========
# module: backend.src.models.user.contribs
class UserContributions(BaseModel):
total_stats: ContributionStats
- # temporarily remove list from total to reduce storage
- # TODO: improve compression so this is not necessary
+ public_stats: ContributionStats
+ total: List[ContributionDay]
- total: List[RepoContributionDay]
+ public: List[ContributionDay]
+ repo_stats: Dict[str, RepoContributionStats]
- repo_stats: Dict[str, ContributionStats]
+ repos: Dict[str, List[ContributionDay]]
- repos: Dict[str, List[RepoContributionDay]]
===========changed ref 5===========
# module: backend.src.external.github_api.graphql.repo
# TODO: create return class
def get_repo(
access_token: str, owner: str, repo: str
) -> Union[Dict[str, Any], List[Any]]:
"""gets all repository data from graphql"""
query = {
"variables": {"owner": owner, "repo": repo},
"query": """
query getRepo($owner: String!, $repo: String!) {
repository(owner: $owner, name: $repo) {
+ isPrivate,
forkCount,
stargazerCount,
languages(first: 5){
totalCount,
totalSize,
edges{
node {
name,
color,
},
size,
},
},
}
}
""",
}
return get_template(query, access_token)["data"]["repository"]
===========changed ref 6===========
# module: backend.src.db.functions.get
@alru_cache(max_size=128)
async def get_user_by_user_id(user_id: str) -> Optional[UserModel]:
user: Optional[Dict[str, Any]] = await USERS.find_one({"user_id": user_id}) # type: ignore
# (flag, value) output through decorator returns value
if user is None:
# flag is false, don't cache
return (False, None) # type: ignore
if "raw_data" not in user:
# flag is false, don't cache
return (False, UserModel.parse_obj(user)) # type: ignore
raw_data = decompress(user["raw_data"])
# flag is true, do cache
+ try:
+ return (True, UserModel.parse_obj({**user, "raw_data": raw_data})) # type: ignore
- return (True, UserModel.parse_obj({**user, "raw_data": raw_data})) # type: ignore
+ except ValidationError:
+ return (False, UserModel.parse_obj({**user, "raw_data": None})) # type: ignore
===========changed ref 7===========
# module: backend.src.processing.user.contributions
def get_contributions(
user_id: str,
access_token: str,
start_date: date = date.today() - timedelta(365),
end_date: date = date.today(),
timezone_str: str = "US/Eastern",
) -> UserContributions:
tz = pytz.timezone(timezone_str)
# get years for contribution calendar
years = sorted(
filter(
lambda x: start_date.year <= x <= end_date.year,
get_user_contribution_years(user_id, access_token),
)
)
dates = [
[
date_to_datetime(max(date(year, 1, 1), start_date)),
date_to_datetime(
min(date(year, 12, 31), end_date), hour=23, minute=59, second=59
),
]
for year in years
]
# async get contribution calendars
calendars: List[RawCalendar] = await gather(
funcs=[get_user_contribution_calendar for _ in years],
args_dicts=[
{
"user_id": user_id,
"access_token": access_token,
"start_date": dates[i][0],
"end_date": dates[i][1],
}
for i in range(len(years))
],
)
all_events: List[t_stats] = await gather(
funcs=[get_user_all_contribution_events for _ in years],
args_dicts=[
{
"user_id": user_id,
"access_token": access_token,
"start_date": dates[i][0],
"end_date": dates[i][1],
}
for i in range(len(years))
],
)
repos_set: Set[str] = set()
for events_year in all_events:
for repo in events_year</s>
|
backend.src.db.functions.compression/compress_stats
|
Modified
|
avgupta456~github-trends
|
7eb9ce05ec5dfc556e396ca647d40fd2c01a0316
|
handle new fields in compression and trim
|
<0>:<add> out = {
<del> return {
|
# module: backend.src.db.functions.compression
def compress_stats(data: Dict[str, Any]) -> Dict[str, Any]:
<0> return {
<1> "counts": (
<2> data["contribs_count"],
<3> data["commits_count"],
<4> data["issues_count"],
<5> data["prs_count"],
<6> data["reviews_count"],
<7> data["repos_count"],
<8> data["other_count"],
<9> ),
<10> "languages": [
<11> (name, stats["color"], stats["additions"], stats["deletions"])
<12> for name, stats in data["languages"].items()
<13> ],
<14> }
<15>
|
===========unchanged ref 0===========
at: typing
Dict = _alias(dict, 2, inst=False, name='Dict')
|
backend.src.db.functions.compression/compress
|
Modified
|
avgupta456~github-trends
|
7eb9ce05ec5dfc556e396ca647d40fd2c01a0316
|
handle new fields in compression and trim
|
<1>:<add> new_public_stats = compress_stats(data["contribs"]["public_stats"])
<10>:<add> )
<add> )
<add>
<add> new_public = list(
<add> map(
<add> lambda x: {
<add> "date": x["date"],
<add> "weekday": x["weekday"],
<add> "stats": compress_stats(x["stats"]),
<add> },
<add> data["contribs"]["public"],
<35>:<add> "public_stats": new_public_stats,
<36>:<add> "public": new_public,
|
# module: backend.src.db.functions.compression
def compress(data: Dict[str, Any]) -> Dict[str, Any]:
<0> new_total_stats = compress_stats(data["contribs"]["total_stats"])
<1>
<2> new_total = list(
<3> map(
<4> lambda x: {
<5> "date": x["date"],
<6> "weekday": x["weekday"],
<7> "stats": compress_stats(x["stats"]),
<8> },
<9> data["contribs"]["total"],
<10> )
<11> )
<12>
<13> new_repo_stats = {
<14> name: compress_stats(stats)
<15> for name, stats in data["contribs"]["repo_stats"].items()
<16> }
<17>
<18> new_repos = {
<19> repo: list(
<20> map(
<21> lambda x: {
<22> "date": x["date"],
<23> "weekday": x["weekday"],
<24> "stats": compress_stats(x["stats"]),
<25> },
<26> data["contribs"]["repos"][repo],
<27> )
<28> )
<29> for repo in data["contribs"]["repos"]
<30> }
<31>
<32> new_data = {
<33> "contribs": {
<34> "total_stats": new_total_stats,
<35> "total": new_total,
<36> "repo_stats": new_repo_stats,
<37> "repos": new_repos,
<38> }
<39> }
<40>
<41> return new_data
<42>
|
===========unchanged ref 0===========
at: backend.src.db.functions.compression
compress_stats(data: Dict[str, Any]) -> Dict[str, Any]
new_repos = {
repo: list(
map(
lambda x: {
"date": x["date"],
"weekday": x["weekday"],
"stats": compress_stats(x["stats"]),
},
data["contribs"]["repos"][repo],
)
)
for repo in data["contribs"]["repos"]
}
at: typing
Dict = _alias(dict, 2, inst=False, name='Dict')
===========changed ref 0===========
# module: backend.src.db.functions.compression
def compress_stats(data: Dict[str, Any]) -> Dict[str, Any]:
+ out = {
- return {
"counts": (
data["contribs_count"],
data["commits_count"],
data["issues_count"],
data["prs_count"],
data["reviews_count"],
data["repos_count"],
data["other_count"],
),
"languages": [
(name, stats["color"], stats["additions"], stats["deletions"])
for name, stats in data["languages"].items()
],
}
|
backend.src.db.functions.compression/decompress_stats
|
Modified
|
avgupta456~github-trends
|
7eb9ce05ec5dfc556e396ca647d40fd2c01a0316
|
handle new fields in compression and trim
|
<0>:<add> out = {
<del> return {
|
# module: backend.src.db.functions.compression
def decompress_stats(data: Dict[str, Any]) -> Dict[str, Any]:
<0> return {
<1> "contribs_count": data["counts"][0],
<2> "commits_count": data["counts"][1],
<3> "issues_count": data["counts"][2],
<4> "prs_count": data["counts"][3],
<5> "reviews_count": data["counts"][4],
<6> "repos_count": data["counts"][5],
<7> "other_count": data["counts"][6],
<8> "languages": {
<9> x[0]: {"color": x[1], "additions": x[2], "deletions": x[3]}
<10> for x in data["languages"]
<11> },
<12> }
<13>
|
===========unchanged ref 0===========
at: backend.src.db.functions.compression.compress
new_total_stats = compress_stats(data["contribs"]["total_stats"])
new_public_stats = compress_stats(data["contribs"]["public_stats"])
new_total = list(
map(
lambda x: {
"date": x["date"],
"weekday": x["weekday"],
"stats": compress_stats(x["stats"]),
},
data["contribs"]["total"],
)
)
new_public = list(
map(
lambda x: {
"date": x["date"],
"weekday": x["weekday"],
"stats": compress_stats(x["stats"]),
},
data["contribs"]["public"],
)
)
new_repo_stats = {
name: compress_stats(stats)
for name, stats in data["contribs"]["repo_stats"].items()
}
new_repos = {
repo: list(
map(
lambda x: {
"date": x["date"],
"weekday": x["weekday"],
"stats": compress_stats(x["stats"]),
},
data["contribs"]["repos"][repo],
)
)
for repo in data["contribs"]["repos"]
}
===========changed ref 0===========
# module: backend.src.db.functions.compression
def compress_stats(data: Dict[str, Any]) -> Dict[str, Any]:
+ out = {
- return {
"counts": (
data["contribs_count"],
data["commits_count"],
data["issues_count"],
data["prs_count"],
data["reviews_count"],
data["repos_count"],
data["other_count"],
),
"languages": [
(name, stats["color"], stats["additions"], stats["deletions"])
for name, stats in data["languages"].items()
],
}
===========changed ref 1===========
# module: backend.src.db.functions.compression
def compress(data: Dict[str, Any]) -> Dict[str, Any]:
new_total_stats = compress_stats(data["contribs"]["total_stats"])
+ new_public_stats = compress_stats(data["contribs"]["public_stats"])
new_total = list(
map(
lambda x: {
"date": x["date"],
"weekday": x["weekday"],
"stats": compress_stats(x["stats"]),
},
data["contribs"]["total"],
+ )
+ )
+
+ new_public = list(
+ map(
+ lambda x: {
+ "date": x["date"],
+ "weekday": x["weekday"],
+ "stats": compress_stats(x["stats"]),
+ },
+ data["contribs"]["public"],
)
)
new_repo_stats = {
name: compress_stats(stats)
for name, stats in data["contribs"]["repo_stats"].items()
}
new_repos = {
repo: list(
map(
lambda x: {
"date": x["date"],
"weekday": x["weekday"],
"stats": compress_stats(x["stats"]),
},
data["contribs"]["repos"][repo],
)
)
for repo in data["contribs"]["repos"]
}
new_data = {
"contribs": {
"total_stats": new_total_stats,
+ "public_stats": new_public_stats,
"total": new_total,
+ "public": new_public,
"repo_stats": new_repo_stats,
"repos": new_repos,
}
}
return new_data
|
backend.src.db.functions.compression/decompress
|
Modified
|
avgupta456~github-trends
|
7eb9ce05ec5dfc556e396ca647d40fd2c01a0316
|
handle new fields in compression and trim
|
<1>:<add> new_public_stats = decompress_stats(data["contribs"]["public_stats"])
<10>:<add> )
<add> )
<add>
<add> new_public = list(
<add> map(
<add> lambda x: {
<add> "date": x["date"],
<add> "weekday": x["weekday"],
<add> "stats": decompress_stats(x["stats"]),
<add> },
<add> data["contribs"]["public"],
<35>:<add> "public_stats": new_public_stats,
<36>:<add> "public": new_public,
|
# module: backend.src.db.functions.compression
def decompress(data: Dict[str, Any]) -> Dict[str, Any]:
<0> new_total_stats = decompress_stats(data["contribs"]["total_stats"])
<1>
<2> new_total = list(
<3> map(
<4> lambda x: {
<5> "date": x["date"],
<6> "weekday": x["weekday"],
<7> "stats": decompress_stats(x["stats"]),
<8> },
<9> data["contribs"]["total"],
<10> )
<11> )
<12>
<13> new_repo_stats = {
<14> name: decompress_stats(stats)
<15> for name, stats in data["contribs"]["repo_stats"].items()
<16> }
<17>
<18> new_repos = {
<19> repo: list(
<20> map(
<21> lambda x: {
<22> "date": x["date"],
<23> "weekday": x["weekday"],
<24> "stats": decompress_stats(x["stats"]),
<25> },
<26> data["contribs"]["repos"][repo],
<27> )
<28> )
<29> for repo in data["contribs"]["repos"]
<30> }
<31>
<32> new_data = {
<33> "contribs": {
<34> "total_stats": new_total_stats,
<35> "total": new_total,
<36> "repo_stats": new_repo_stats,
<37> "repos": new_repos,
<38> }
<39> }
<40>
<41> return new_data
<42>
|
===========unchanged ref 0===========
at: backend.src.db.functions.compression.compress
new_data = {
"contribs": {
"total_stats": new_total_stats,
"public_stats": new_public_stats,
"total": new_total,
"public": new_public,
"repo_stats": new_repo_stats,
"repos": new_repos,
}
}
at: typing
Dict = _alias(dict, 2, inst=False, name='Dict')
===========changed ref 0===========
# module: backend.src.db.functions.compression
def decompress_stats(data: Dict[str, Any]) -> Dict[str, Any]:
+ out = {
- return {
"contribs_count": data["counts"][0],
"commits_count": data["counts"][1],
"issues_count": data["counts"][2],
"prs_count": data["counts"][3],
"reviews_count": data["counts"][4],
"repos_count": data["counts"][5],
"other_count": data["counts"][6],
"languages": {
x[0]: {"color": x[1], "additions": x[2], "deletions": x[3]}
for x in data["languages"]
},
}
===========changed ref 1===========
# module: backend.src.db.functions.compression
def compress_stats(data: Dict[str, Any]) -> Dict[str, Any]:
+ out = {
- return {
"counts": (
data["contribs_count"],
data["commits_count"],
data["issues_count"],
data["prs_count"],
data["reviews_count"],
data["repos_count"],
data["other_count"],
),
"languages": [
(name, stats["color"], stats["additions"], stats["deletions"])
for name, stats in data["languages"].items()
],
}
===========changed ref 2===========
# module: backend.src.db.functions.compression
def compress(data: Dict[str, Any]) -> Dict[str, Any]:
new_total_stats = compress_stats(data["contribs"]["total_stats"])
+ new_public_stats = compress_stats(data["contribs"]["public_stats"])
new_total = list(
map(
lambda x: {
"date": x["date"],
"weekday": x["weekday"],
"stats": compress_stats(x["stats"]),
},
data["contribs"]["total"],
+ )
+ )
+
+ new_public = list(
+ map(
+ lambda x: {
+ "date": x["date"],
+ "weekday": x["weekday"],
+ "stats": compress_stats(x["stats"]),
+ },
+ data["contribs"]["public"],
)
)
new_repo_stats = {
name: compress_stats(stats)
for name, stats in data["contribs"]["repo_stats"].items()
}
new_repos = {
repo: list(
map(
lambda x: {
"date": x["date"],
"weekday": x["weekday"],
"stats": compress_stats(x["stats"]),
},
data["contribs"]["repos"][repo],
)
)
for repo in data["contribs"]["repos"]
}
new_data = {
"contribs": {
"total_stats": new_total_stats,
+ "public_stats": new_public_stats,
"total": new_total,
+ "public": new_public,
"repo_stats": new_repo_stats,
"repos": new_repos,
}
}
return new_data
|
backend.src.analytics.user.utils/trim_package
|
Modified
|
avgupta456~github-trends
|
7eb9ce05ec5dfc556e396ca647d40fd2c01a0316
|
handle new fields in compression and trim
|
<4>:<add> new_public, new_public_stats = trim_contribs(
<add> data.contribs.public, start_date, end_date
<add> )
<add>
<add> new_repos: Dict[str, Any] = {}
<add> new_repo_stats: Dict[str, Any] = {}
<del> new_repos = {}
<5>:<del> new_repo_stats = {}
<12>:<add> for repo in new_repo_stats:
<add> new_repo_stats[repo]["private"] = data.contribs.repo_stats[repo].private
<add>
<14>:<add> "public_stats": new_public_stats,
<15>:<add> "public": new_public,
|
# module: backend.src.analytics.user.utils
def trim_package(data: UserPackage, start_date: date, end_date: date) -> UserPackage:
<0> new_total, new_total_stats = trim_contribs(
<1> data.contribs.total, start_date, end_date
<2> )
<3>
<4> new_repos = {}
<5> new_repo_stats = {}
<6> for repo_name, repo in data.contribs.repos.items():
<7> new_repo_total, new_repo_total_stats = trim_contribs(repo, start_date, end_date)
<8> if len(new_repo_total) > 0:
<9> new_repos[repo_name] = new_repo_total
<10> new_repo_stats[repo_name] = new_repo_total_stats
<11>
<12> new_data = {
<13> "total_stats": new_total_stats,
<14> "total": new_total,
<15> "repo_stats": new_repo_stats,
<16> "repos": new_repos,
<17> }
<18>
<19> return UserPackage.parse_obj({"contribs": new_data})
<20>
|
===========unchanged ref 0===========
at: backend.src.analytics.user.utils
trim_contribs(contribs: List[ContributionDay], start_date: date, end_date: date) -> Tuple[List[ContributionDay], Dict[str, Any]]
at: datetime
date()
at: src.models.user.contribs.RepoContributionStats
private: bool
contribs_count: int
commits_count: int
issues_count: int
prs_count: int
reviews_count: int
repos_count: int
other_count: int
languages: Dict[str, Language]
at: src.models.user.contribs.UserContributions
total_stats: ContributionStats
public_stats: ContributionStats
total: List[ContributionDay]
public: List[ContributionDay]
repo_stats: Dict[str, RepoContributionStats]
repos: Dict[str, List[ContributionDay]]
at: src.models.user.package.UserPackage
contribs: UserContributions
at: typing
Dict = _alias(dict, 2, inst=False, name='Dict')
===========changed ref 0===========
# module: backend.src.db.functions.compression
def compress_stats(data: Dict[str, Any]) -> Dict[str, Any]:
+ out = {
- return {
"counts": (
data["contribs_count"],
data["commits_count"],
data["issues_count"],
data["prs_count"],
data["reviews_count"],
data["repos_count"],
data["other_count"],
),
"languages": [
(name, stats["color"], stats["additions"], stats["deletions"])
for name, stats in data["languages"].items()
],
}
===========changed ref 1===========
# module: backend.src.db.functions.compression
def decompress_stats(data: Dict[str, Any]) -> Dict[str, Any]:
+ out = {
- return {
"contribs_count": data["counts"][0],
"commits_count": data["counts"][1],
"issues_count": data["counts"][2],
"prs_count": data["counts"][3],
"reviews_count": data["counts"][4],
"repos_count": data["counts"][5],
"other_count": data["counts"][6],
"languages": {
x[0]: {"color": x[1], "additions": x[2], "deletions": x[3]}
for x in data["languages"]
},
}
===========changed ref 2===========
# module: backend.src.db.functions.compression
def decompress(data: Dict[str, Any]) -> Dict[str, Any]:
new_total_stats = decompress_stats(data["contribs"]["total_stats"])
+ new_public_stats = decompress_stats(data["contribs"]["public_stats"])
new_total = list(
map(
lambda x: {
"date": x["date"],
"weekday": x["weekday"],
"stats": decompress_stats(x["stats"]),
},
data["contribs"]["total"],
+ )
+ )
+
+ new_public = list(
+ map(
+ lambda x: {
+ "date": x["date"],
+ "weekday": x["weekday"],
+ "stats": decompress_stats(x["stats"]),
+ },
+ data["contribs"]["public"],
)
)
new_repo_stats = {
name: decompress_stats(stats)
for name, stats in data["contribs"]["repo_stats"].items()
}
new_repos = {
repo: list(
map(
lambda x: {
"date": x["date"],
"weekday": x["weekday"],
"stats": decompress_stats(x["stats"]),
},
data["contribs"]["repos"][repo],
)
)
for repo in data["contribs"]["repos"]
}
new_data = {
"contribs": {
"total_stats": new_total_stats,
+ "public_stats": new_public_stats,
"total": new_total,
+ "public": new_public,
"repo_stats": new_repo_stats,
"repos": new_repos,
}
}
return new_data
===========changed ref 3===========
# module: backend.src.db.functions.compression
def compress(data: Dict[str, Any]) -> Dict[str, Any]:
new_total_stats = compress_stats(data["contribs"]["total_stats"])
+ new_public_stats = compress_stats(data["contribs"]["public_stats"])
new_total = list(
map(
lambda x: {
"date": x["date"],
"weekday": x["weekday"],
"stats": compress_stats(x["stats"]),
},
data["contribs"]["total"],
+ )
+ )
+
+ new_public = list(
+ map(
+ lambda x: {
+ "date": x["date"],
+ "weekday": x["weekday"],
+ "stats": compress_stats(x["stats"]),
+ },
+ data["contribs"]["public"],
)
)
new_repo_stats = {
name: compress_stats(stats)
for name, stats in data["contribs"]["repo_stats"].items()
}
new_repos = {
repo: list(
map(
lambda x: {
"date": x["date"],
"weekday": x["weekday"],
"stats": compress_stats(x["stats"]),
},
data["contribs"]["repos"][repo],
)
)
for repo in data["contribs"]["repos"]
}
new_data = {
"contribs": {
"total_stats": new_total_stats,
+ "public_stats": new_public_stats,
"total": new_total,
+ "public": new_public,
"repo_stats": new_repo_stats,
"repos": new_repos,
}
}
return new_data
|
backend.src.analytics.user.commits/get_top_languages
|
Modified
|
avgupta456~github-trends
|
7eb9ce05ec5dfc556e396ca647d40fd2c01a0316
|
handle new fields in compression and trim
|
<0>:<add> raw_languages = (
<add> data.contribs.total_stats.languages
<del> raw_languages = data.contribs.total_stats.languages
<1>:<add> if include_private
<add> else data.contribs.public_stats.languages
<add> )
<add>
|
# module: backend.src.analytics.user.commits
+ def get_top_languages(data: UserPackage, include_private: bool) -> List[LanguageStats]:
- def get_top_languages(data: UserPackage) -> List[LanguageStats]:
<0> raw_languages = data.contribs.total_stats.languages
<1> languages_list: List[dict_type] = [
<2> {
<3> "lang": lang,
<4> "color": stats.color,
<5> "additions": stats.additions,
<6> "deletions": stats.deletions,
<7> }
<8> for lang, stats in raw_languages.items()
<9> ]
<10>
<11> total_additions = sum([int(lang["additions"]) for lang in languages_list])
<12> total_deletions = sum([int(lang["deletions"]) for lang in languages_list])
<13> total_changed = total_additions + total_deletions + 1 # avoids division by zero
<14> total: dict_type = {
<15> "lang": "Total",
<16> "additions": total_additions,
<17> "deletions": total_deletions,
<18> }
<19>
<20> languages_list = sorted(
<21> languages_list,
<22> key=lambda x: int(x["additions"]) + int(x["deletions"]),
<23> reverse=True,
<24> )
<25> other: dict_type = {
<26> "lang": "Other",
<27> "additions": 0,
<28> "deletions": 0,
<29> "color": "#ededed",
<30> }
<31> for language in languages_list[4:]:
<32> other["additions"] = int(other["additions"]) + int(language["additions"])
<33> other["deletions"] = int(other["deletions"]) + int(language["deletions"])
<34>
<35> languages_list = [total] + languages_list[:4] + [other]
<36>
<37> new_languages_list: List[LanguageStats] = []
<38> for lang in languages_list:
<39> lang["added"] =</s>
|
===========below chunk 0===========
# module: backend.src.analytics.user.commits
+ def get_top_languages(data: UserPackage, include_private: bool) -> List[LanguageStats]:
- def get_top_languages(data: UserPackage) -> List[LanguageStats]:
# offset: 1
lang["changed"] = int(lang["additions"]) + int(lang["deletions"])
lang["percent"] = float(round(100 * lang["changed"] / total_changed, 2))
if lang["percent"] > 0:
new_languages_list.append(LanguageStats.parse_obj(lang))
return new_languages_list
===========unchanged ref 0===========
at: backend.src.analytics.user.commits
dict_type = Dict[str, Union[str, int, float]]
at: src.models.user.contribs.ContributionStats
contribs_count: int
commits_count: int
issues_count: int
prs_count: int
reviews_count: int
repos_count: int
other_count: int
languages: Dict[str, Language]
at: src.models.user.contribs.Language
color: str
additions: int
deletions: int
at: src.models.user.contribs.UserContributions
total_stats: ContributionStats
public_stats: ContributionStats
total: List[ContributionDay]
public: List[ContributionDay]
repo_stats: Dict[str, RepoContributionStats]
repos: Dict[str, List[ContributionDay]]
at: src.models.user.package.UserPackage
contribs: UserContributions
at: typing
List = _alias(list, 1, inst=False, name='List')
===========changed ref 0===========
# module: backend.src.db.functions.compression
def compress_stats(data: Dict[str, Any]) -> Dict[str, Any]:
+ out = {
- return {
"counts": (
data["contribs_count"],
data["commits_count"],
data["issues_count"],
data["prs_count"],
data["reviews_count"],
data["repos_count"],
data["other_count"],
),
"languages": [
(name, stats["color"], stats["additions"], stats["deletions"])
for name, stats in data["languages"].items()
],
}
===========changed ref 1===========
# module: backend.src.db.functions.compression
def decompress_stats(data: Dict[str, Any]) -> Dict[str, Any]:
+ out = {
- return {
"contribs_count": data["counts"][0],
"commits_count": data["counts"][1],
"issues_count": data["counts"][2],
"prs_count": data["counts"][3],
"reviews_count": data["counts"][4],
"repos_count": data["counts"][5],
"other_count": data["counts"][6],
"languages": {
x[0]: {"color": x[1], "additions": x[2], "deletions": x[3]}
for x in data["languages"]
},
}
===========changed ref 2===========
# module: backend.src.analytics.user.utils
def trim_package(data: UserPackage, start_date: date, end_date: date) -> UserPackage:
new_total, new_total_stats = trim_contribs(
data.contribs.total, start_date, end_date
)
+ new_public, new_public_stats = trim_contribs(
+ data.contribs.public, start_date, end_date
+ )
+
+ new_repos: Dict[str, Any] = {}
+ new_repo_stats: Dict[str, Any] = {}
- new_repos = {}
- new_repo_stats = {}
for repo_name, repo in data.contribs.repos.items():
new_repo_total, new_repo_total_stats = trim_contribs(repo, start_date, end_date)
if len(new_repo_total) > 0:
new_repos[repo_name] = new_repo_total
new_repo_stats[repo_name] = new_repo_total_stats
+ for repo in new_repo_stats:
+ new_repo_stats[repo]["private"] = data.contribs.repo_stats[repo].private
+
new_data = {
"total_stats": new_total_stats,
+ "public_stats": new_public_stats,
"total": new_total,
+ "public": new_public,
"repo_stats": new_repo_stats,
"repos": new_repos,
}
return UserPackage.parse_obj({"contribs": new_data})
===========changed ref 3===========
# module: backend.src.db.functions.compression
def decompress(data: Dict[str, Any]) -> Dict[str, Any]:
new_total_stats = decompress_stats(data["contribs"]["total_stats"])
+ new_public_stats = decompress_stats(data["contribs"]["public_stats"])
new_total = list(
map(
lambda x: {
"date": x["date"],
"weekday": x["weekday"],
"stats": decompress_stats(x["stats"]),
},
data["contribs"]["total"],
+ )
+ )
+
+ new_public = list(
+ map(
+ lambda x: {
+ "date": x["date"],
+ "weekday": x["weekday"],
+ "stats": decompress_stats(x["stats"]),
+ },
+ data["contribs"]["public"],
)
)
new_repo_stats = {
name: decompress_stats(stats)
for name, stats in data["contribs"]["repo_stats"].items()
}
new_repos = {
repo: list(
map(
lambda x: {
"date": x["date"],
"weekday": x["weekday"],
"stats": decompress_stats(x["stats"]),
},
data["contribs"]["repos"][repo],
)
)
for repo in data["contribs"]["repos"]
}
new_data = {
"contribs": {
"total_stats": new_total_stats,
+ "public_stats": new_public_stats,
"total": new_total,
+ "public": new_public,
"repo_stats": new_repo_stats,
"repos": new_repos,
}
}
return new_data
|
backend.src.analytics.user.commits/get_top_repos
|
Modified
|
avgupta456~github-trends
|
7eb9ce05ec5dfc556e396ca647d40fd2c01a0316
|
handle new fields in compression and trim
|
<16>:<add> if include_private or not repo_stats.private
|
# module: backend.src.analytics.user.commits
+ def get_top_repos(data: UserPackage, include_private: bool) -> List[RepoStats]:
- def get_top_repos(data: UserPackage) -> List[RepoStats]:
<0> repos: List[Any] = [
<1> {
<2> "repo": repo,
<3> "langs": [
<4> {
<5> "lang": x[0],
<6> "color": x[1].color,
<7> "additions": x[1].additions,
<8> "deletions": x[1].deletions,
<9> }
<10> for x in list(repo_stats.languages.items())
<11> ],
<12> "additions": sum([x.additions for x in repo_stats.languages.values()]),
<13> "deletions": sum([x.deletions for x in repo_stats.languages.values()]),
<14> }
<15> for repo, repo_stats in data.contribs.repo_stats.items()
<16> ]
<17>
<18> for repo in repos:
<19> repo["added"] = int(repo["additions"]) - int(repo["deletions"])
<20> repo["changed"] = int(repo["additions"]) + int(repo["deletions"])
<21> repo["langs"] = [
<22> x
<23> for x in repo["langs"]
<24> if x["additions"] + x["deletions"] > 0.05 * repo["changed"]
<25> ]
<26>
<27> repos = sorted(repos, key=lambda x: x["changed"], reverse=True)
<28>
<29> new_repos = [
<30> RepoStats.parse_obj(x)
<31> for x in repos
<32> if x["changed"] > 0.05 * repos[0]["changed"]
<33> ]
<34>
<35> return new_repos[:5]
<36>
|
===========unchanged ref 0===========
at: backend.src.analytics.user.commits.get_top_languages
new_languages_list: List[LanguageStats] = []
lang["added"] = int(lang["additions"]) - int(lang["deletions"])
lang["percent"] = float(round(100 * lang["changed"] / total_changed, 2))
at: src.models.user.contribs.Language
color: str
additions: int
deletions: int
at: src.models.user.contribs.RepoContributionStats
private: bool
contribs_count: int
commits_count: int
issues_count: int
prs_count: int
reviews_count: int
repos_count: int
other_count: int
languages: Dict[str, Language]
at: src.models.user.contribs.UserContributions
repo_stats: Dict[str, RepoContributionStats]
at: src.models.user.package.UserPackage
contribs: UserContributions
at: typing
List = _alias(list, 1, inst=False, name='List')
===========changed ref 0===========
# module: backend.src.analytics.user.commits
+ def get_top_languages(data: UserPackage, include_private: bool) -> List[LanguageStats]:
- def get_top_languages(data: UserPackage) -> List[LanguageStats]:
+ raw_languages = (
+ data.contribs.total_stats.languages
- raw_languages = data.contribs.total_stats.languages
+ if include_private
+ else data.contribs.public_stats.languages
+ )
+
languages_list: List[dict_type] = [
{
"lang": lang,
"color": stats.color,
"additions": stats.additions,
"deletions": stats.deletions,
}
for lang, stats in raw_languages.items()
]
total_additions = sum([int(lang["additions"]) for lang in languages_list])
total_deletions = sum([int(lang["deletions"]) for lang in languages_list])
total_changed = total_additions + total_deletions + 1 # avoids division by zero
total: dict_type = {
"lang": "Total",
"additions": total_additions,
"deletions": total_deletions,
}
languages_list = sorted(
languages_list,
key=lambda x: int(x["additions"]) + int(x["deletions"]),
reverse=True,
)
other: dict_type = {
"lang": "Other",
"additions": 0,
"deletions": 0,
"color": "#ededed",
}
for language in languages_list[4:]:
other["additions"] = int(other["additions"]) + int(language["additions"])
other["deletions"] = int(other["deletions"]) + int(language["deletions"])
languages_list = [total] + languages_list[:4] + [other]
new_languages_list: List[LanguageStats] = []
for lang in languages_</s>
===========changed ref 1===========
# module: backend.src.analytics.user.commits
+ def get_top_languages(data: UserPackage, include_private: bool) -> List[LanguageStats]:
- def get_top_languages(data: UserPackage) -> List[LanguageStats]:
# offset: 1
<s>[:4] + [other]
new_languages_list: List[LanguageStats] = []
for lang in languages_list:
lang["added"] = int(lang["additions"]) - int(lang["deletions"])
lang["changed"] = int(lang["additions"]) + int(lang["deletions"])
lang["percent"] = float(round(100 * lang["changed"] / total_changed, 2))
if lang["percent"] > 0:
new_languages_list.append(LanguageStats.parse_obj(lang))
return new_languages_list
===========changed ref 2===========
# module: backend.src.db.functions.compression
def compress_stats(data: Dict[str, Any]) -> Dict[str, Any]:
+ out = {
- return {
"counts": (
data["contribs_count"],
data["commits_count"],
data["issues_count"],
data["prs_count"],
data["reviews_count"],
data["repos_count"],
data["other_count"],
),
"languages": [
(name, stats["color"], stats["additions"], stats["deletions"])
for name, stats in data["languages"].items()
],
}
===========changed ref 3===========
# module: backend.src.db.functions.compression
def decompress_stats(data: Dict[str, Any]) -> Dict[str, Any]:
+ out = {
- return {
"contribs_count": data["counts"][0],
"commits_count": data["counts"][1],
"issues_count": data["counts"][2],
"prs_count": data["counts"][3],
"reviews_count": data["counts"][4],
"repos_count": data["counts"][5],
"other_count": data["counts"][6],
"languages": {
x[0]: {"color": x[1], "additions": x[2], "deletions": x[3]}
for x in data["languages"]
},
}
===========changed ref 4===========
# module: backend.src.analytics.user.utils
def trim_package(data: UserPackage, start_date: date, end_date: date) -> UserPackage:
new_total, new_total_stats = trim_contribs(
data.contribs.total, start_date, end_date
)
+ new_public, new_public_stats = trim_contribs(
+ data.contribs.public, start_date, end_date
+ )
+
+ new_repos: Dict[str, Any] = {}
+ new_repo_stats: Dict[str, Any] = {}
- new_repos = {}
- new_repo_stats = {}
for repo_name, repo in data.contribs.repos.items():
new_repo_total, new_repo_total_stats = trim_contribs(repo, start_date, end_date)
if len(new_repo_total) > 0:
new_repos[repo_name] = new_repo_total
new_repo_stats[repo_name] = new_repo_total_stats
+ for repo in new_repo_stats:
+ new_repo_stats[repo]["private"] = data.contribs.repo_stats[repo].private
+
new_data = {
"total_stats": new_total_stats,
+ "public_stats": new_public_stats,
"total": new_total,
+ "public": new_public,
"repo_stats": new_repo_stats,
"repos": new_repos,
}
return UserPackage.parse_obj({"contribs": new_data})
|
backend.src.db.functions.get/get_user_by_user_id
|
Modified
|
avgupta456~github-trends
|
8d425a6fe15feb4afee6d724032f56d90ea956df
|
docker communicate between containers
|
<12>:<del> raw_data = decompress(user["raw_data"])
<13>:<del>
<14>:<del> # flag is true, do cache
<16>:<add> raw_data = decompress(user["raw_data"])
<add> # flag is true, do cache
<17>:<add> except (KeyError, ValidationError):
<del> except ValidationError:
|
# module: backend.src.db.functions.get
@alru_cache(max_size=128)
async def get_user_by_user_id(user_id: str) -> Optional[UserModel]:
<0> user: Optional[Dict[str, Any]] = await USERS.find_one({"user_id": user_id}) # type: ignore
<1>
<2> # (flag, value) output through decorator returns value
<3>
<4> if user is None:
<5> # flag is false, don't cache
<6> return (False, None) # type: ignore
<7>
<8> if "raw_data" not in user:
<9> # flag is false, don't cache
<10> return (False, UserModel.parse_obj(user)) # type: ignore
<11>
<12> raw_data = decompress(user["raw_data"])
<13>
<14> # flag is true, do cache
<15> try:
<16> return (True, UserModel.parse_obj({**user, "raw_data": raw_data})) # type: ignore
<17> except ValidationError:
<18> return (False, UserModel.parse_obj({**user, "raw_data": None})) # type: ignore
<19>
|
===========unchanged ref 0===========
at: src.db.functions.compression
decompress(data: Dict[str, Any]) -> Dict[str, Any]
at: src.db.mongodb
USERS = DB.users # type: ignore
at: src.helper.alru_cache
alru_cache(max_size: int=128, ttl: timedelta=timedelta(hours=1))
at: typing
Dict = _alias(dict, 2, inst=False, name='Dict')
===========changed ref 0===========
# module: backend.src.constants
# GLOBAL
PROD = os.getenv("PROD", "False") == "True"
+ DOCKER = os.getenv("DOCKER", "False") == "True"
PROJECT_ID = "github-298920"
BACKEND_URL = "https://api.githubtrends.io" if PROD else "http://localhost:8000"
# API
TIMEOUT = 15 # max seconds to wait for api response
NODE_CHUNK_SIZE = 40 # number of nodes (commits) to query (max 100)
NODE_THREADS = 40 # number of node queries simultaneously (avoid blacklisting)
CUTOFF = 500 # if > cutoff lines, assume imported, don't count
# CUSTOMIZATION
BLACKLIST = ["Jupyter Notebook", "HTML"] # languages to ignore
# OAUTH
OAUTH_CLIENT_ID = os.getenv("OAUTH_CLIENT_ID", "") # client ID for GitHub OAuth App
OAUTH_CLIENT_SECRET = os.getenv("OAUTH_CLIENT_SECRET", "") # client secret for App
OAUTH_REDIRECT_URI = os.getenv("OAUTH_REDIRECT_URI", "") # redirect uri for App
# PUBSUB
PUBSUB_PUB = os.getenv("PUBSUB_PUB", "False") == "True"
PUBSUB_TOKEN = os.getenv("PUBSUB_TOKEN", "")
+ LOCAL_SUBSCRIBER = ( # based on name of Docker container
+ "http://" + ("subscriber" if DOCKER else "localhost") + ":8001/pubsub/sub/"
+ )
+
- LOCAL_SUBSCRIBER = "http://localhost:8001/pubsub/sub/"
# MONGODB
MONGODB_PASSWORD = os.getenv("MONGODB_PASSWORD", "")
# SENTRY
SENTRY_DSN = os.getenv("SENTRY_DSN", "")
# TESTING
TEST_USER_ID = "AshishGupta938" # for testing, previously "avgupta456"
TEST_TOKEN = os.getenv("AUTH_TOKEN", "") # for authentication
|
backend.src.db.functions.get/get_user_by_access_token
|
Modified
|
avgupta456~github-trends
|
8d425a6fe15feb4afee6d724032f56d90ea956df
|
docker communicate between containers
|
<14>:<add> try:
<add> raw_data = decompress(user["raw_data"])
<del> raw_data = decompress(user["raw_data"])
<15>:<add> # flag is true, do cache
<add> return (True, UserModel.parse_obj({**user, "raw_data": raw_data})) # type: ignore
<add> except (KeyError, ValidationError):
<add> return (False, UserModel.parse_obj({**user, "raw_data": None})) # type: ignore
<16>:<del> # flag is true, do cache
<17>:<del> return (True, UserModel.parse_obj({**user, "raw_data": raw_data})) # type: ignore
<18>:<del>
|
# module: backend.src.db.functions.get
@alru_cache(max_size=128)
async def get_user_by_access_token(access_token: str) -> Optional[UserModel]:
<0> user: Optional[Dict[str, Any]] = await USERS.find_one( # type: ignore
<1> {"access_token": access_token}
<2> )
<3>
<4> # (flag, value) output through decorator returns value
<5>
<6> if user is None:
<7> # flag is false, don't cache
<8> return (False, None) # type: ignore
<9>
<10> if "raw_data" not in user:
<11> # flag is false, don't cache
<12> return (False, UserModel.parse_obj(user)) # type: ignore
<13>
<14> raw_data = decompress(user["raw_data"])
<15>
<16> # flag is true, do cache
<17> return (True, UserModel.parse_obj({**user, "raw_data": raw_data})) # type: ignore
<18>
|
===========unchanged ref 0===========
at: src.db.functions.compression
decompress(data: Dict[str, Any]) -> Dict[str, Any]
at: src.db.mongodb
USERS = DB.users # type: ignore
at: typing
Dict = _alias(dict, 2, inst=False, name='Dict')
===========changed ref 0===========
# module: backend.src.db.functions.get
@alru_cache(max_size=128)
async def get_user_by_user_id(user_id: str) -> Optional[UserModel]:
user: Optional[Dict[str, Any]] = await USERS.find_one({"user_id": user_id}) # type: ignore
# (flag, value) output through decorator returns value
if user is None:
# flag is false, don't cache
return (False, None) # type: ignore
if "raw_data" not in user:
# flag is false, don't cache
return (False, UserModel.parse_obj(user)) # type: ignore
- raw_data = decompress(user["raw_data"])
-
- # flag is true, do cache
try:
+ raw_data = decompress(user["raw_data"])
+ # flag is true, do cache
return (True, UserModel.parse_obj({**user, "raw_data": raw_data})) # type: ignore
+ except (KeyError, ValidationError):
- except ValidationError:
return (False, UserModel.parse_obj({**user, "raw_data": None})) # type: ignore
===========changed ref 1===========
# module: backend.src.constants
# GLOBAL
PROD = os.getenv("PROD", "False") == "True"
+ DOCKER = os.getenv("DOCKER", "False") == "True"
PROJECT_ID = "github-298920"
BACKEND_URL = "https://api.githubtrends.io" if PROD else "http://localhost:8000"
# API
TIMEOUT = 15 # max seconds to wait for api response
NODE_CHUNK_SIZE = 40 # number of nodes (commits) to query (max 100)
NODE_THREADS = 40 # number of node queries simultaneously (avoid blacklisting)
CUTOFF = 500 # if > cutoff lines, assume imported, don't count
# CUSTOMIZATION
BLACKLIST = ["Jupyter Notebook", "HTML"] # languages to ignore
# OAUTH
OAUTH_CLIENT_ID = os.getenv("OAUTH_CLIENT_ID", "") # client ID for GitHub OAuth App
OAUTH_CLIENT_SECRET = os.getenv("OAUTH_CLIENT_SECRET", "") # client secret for App
OAUTH_REDIRECT_URI = os.getenv("OAUTH_REDIRECT_URI", "") # redirect uri for App
# PUBSUB
PUBSUB_PUB = os.getenv("PUBSUB_PUB", "False") == "True"
PUBSUB_TOKEN = os.getenv("PUBSUB_TOKEN", "")
+ LOCAL_SUBSCRIBER = ( # based on name of Docker container
+ "http://" + ("subscriber" if DOCKER else "localhost") + ":8001/pubsub/sub/"
+ )
+
- LOCAL_SUBSCRIBER = "http://localhost:8001/pubsub/sub/"
# MONGODB
MONGODB_PASSWORD = os.getenv("MONGODB_PASSWORD", "")
# SENTRY
SENTRY_DSN = os.getenv("SENTRY_DSN", "")
# TESTING
TEST_USER_ID = "AshishGupta938" # for testing, previously "avgupta456"
TEST_TOKEN = os.getenv("AUTH_TOKEN", "") # for authentication
|
backend.src.routers.users.svg/get_user_lang_svg
|
Modified
|
avgupta456~github-trends
|
f2f838dda7eb246b10f551dde76c364bac2d7c92
|
pass include private
|
<4>:<add> processed = get_top_languages(output, include_private)
<del> processed = get_top_languages(output)
<5>:<add> out = get_top_langs_svg(processed, time_str, use_percent, include_private)
<del> out = get_top_langs_svg(processed, time_str, use_percent)
|
<s> response_class=HTMLResponse
)
@svg_fail_gracefully
async def get_user_lang_svg(
response: Response,
user_id: str,
start_date: date = date.today() - timedelta(365),
end_date: date = date.today(),
time_range: str = "one_year",
timezone_str: str = "US/Eastern",
use_percent: bool = False,
+ include_private: bool = True,
) -> Any:
<0> start_date, end_date, time_str = use_time_range(time_range, start_date, end_date)
<1> output = await get_user(user_id, start_date, end_date)
<2> if output is None:
<3> return get_loading_svg()
<4> processed = get_top_languages(output)
<5> out = get_top_langs_svg(processed, time_str, use_percent)
<6> return out
<7>
|
===========unchanged ref 0===========
at: backend.src.routers.users.svg
router = APIRouter()
at: datetime
timedelta(days: float=..., seconds: float=..., microseconds: float=..., milliseconds: float=..., minutes: float=..., hours: float=..., weeks: float=..., *, fold: int=...)
date()
at: datetime.date
__slots__ = '_year', '_month', '_day', '_hashcode'
today() -> _S
__str__ = isoformat
__radd__ = __add__
at: src.analytics.user.commits
get_top_languages(data: UserPackage, include_private: bool) -> List[LanguageStats]
at: src.routers.users.get_data
get_user(user_id: str, start_date: date, end_date: date) -> Optional[UserPackage]
at: src.svg.error
get_loading_svg() -> Drawing
at: src.svg.top_langs
get_top_langs_svg(data: List[LanguageStats], time_str: str, use_percent: bool, include_private: bool) -> Drawing
at: src.utils
svg_fail_gracefully(func: Callable[..., Any])
use_time_range(time_range: str, start_date: date, end_date: date) -> Tuple[date, date, str]
|
backend.src.routers.users.svg/get_user_repo_svg
|
Modified
|
avgupta456~github-trends
|
f2f838dda7eb246b10f551dde76c364bac2d7c92
|
pass include private
|
<4>:<add> processed = get_top_repos(output, include_private)
<del> processed = get_top_repos(output)
<5>:<add> return get_top_repos_svg(processed, time_str, include_private)
<del> return get_top_repos_svg(processed, time_str)
|
<s>code=status.HTTP_200_OK, response_class=HTMLResponse
)
@svg_fail_gracefully
async def get_user_repo_svg(
response: Response,
user_id: str,
start_date: date = date.today() - timedelta(365),
end_date: date = date.today(),
time_range: str = "one_year",
timezone_str: str = "US/Eastern",
+ include_private: bool = True,
) -> Any:
<0> start_date, end_date, time_str = use_time_range(time_range, start_date, end_date)
<1> output = await get_user(user_id, start_date, end_date)
<2> if output is None:
<3> return get_loading_svg()
<4> processed = get_top_repos(output)
<5> return get_top_repos_svg(processed, time_str)
<6>
|
===========unchanged ref 0===========
at: backend.src.routers.users.svg
router = APIRouter()
at: datetime
timedelta(days: float=..., seconds: float=..., microseconds: float=..., milliseconds: float=..., minutes: float=..., hours: float=..., weeks: float=..., *, fold: int=...)
date()
at: datetime.date
today() -> _S
at: src.routers.users.get_data
get_user(user_id: str, start_date: date, end_date: date) -> Optional[UserPackage]
at: src.svg.error
get_loading_svg() -> Drawing
at: src.utils
svg_fail_gracefully(func: Callable[..., Any])
use_time_range(time_range: str, start_date: date, end_date: date) -> Tuple[date, date, str]
===========changed ref 0===========
<s> response_class=HTMLResponse
)
@svg_fail_gracefully
async def get_user_lang_svg(
response: Response,
user_id: str,
start_date: date = date.today() - timedelta(365),
end_date: date = date.today(),
time_range: str = "one_year",
timezone_str: str = "US/Eastern",
use_percent: bool = False,
+ include_private: bool = True,
) -> Any:
start_date, end_date, time_str = use_time_range(time_range, start_date, end_date)
output = await get_user(user_id, start_date, end_date)
if output is None:
return get_loading_svg()
+ processed = get_top_languages(output, include_private)
- processed = get_top_languages(output)
+ out = get_top_langs_svg(processed, time_str, use_percent, include_private)
- out = get_top_langs_svg(processed, time_str, use_percent)
return out
|
backend.src.analytics.user.commits/get_top_repos
|
Modified
|
avgupta456~github-trends
|
bc646c7b8156a10aedcec7bd2dbf41ef15c263ed
|
smaller cutoff
|
<33>:<add> if x["changed"] > 0.01 * repos[0]["changed"]
<del> if x["changed"] > 0.05 * repos[0]["changed"]
|
# module: backend.src.analytics.user.commits
def get_top_repos(data: UserPackage, include_private: bool) -> List[RepoStats]:
<0> repos: List[Any] = [
<1> {
<2> "repo": repo,
<3> "langs": [
<4> {
<5> "lang": x[0],
<6> "color": x[1].color,
<7> "additions": x[1].additions,
<8> "deletions": x[1].deletions,
<9> }
<10> for x in list(repo_stats.languages.items())
<11> ],
<12> "additions": sum([x.additions for x in repo_stats.languages.values()]),
<13> "deletions": sum([x.deletions for x in repo_stats.languages.values()]),
<14> }
<15> for repo, repo_stats in data.contribs.repo_stats.items()
<16> if include_private or not repo_stats.private
<17> ]
<18>
<19> for repo in repos:
<20> repo["added"] = int(repo["additions"]) - int(repo["deletions"])
<21> repo["changed"] = int(repo["additions"]) + int(repo["deletions"])
<22> repo["langs"] = [
<23> x
<24> for x in repo["langs"]
<25> if x["additions"] + x["deletions"] > 0.05 * repo["changed"]
<26> ]
<27>
<28> repos = sorted(repos, key=lambda x: x["changed"], reverse=True)
<29>
<30> new_repos = [
<31> RepoStats.parse_obj(x)
<32> for x in repos
<33> if x["changed"] > 0.05 * repos[0]["changed"]
<34> ]
<35>
<36> return new_repos[:5]
<37>
|
===========unchanged ref 0===========
at: src.models.user.contribs.Language
color: str
additions: int
deletions: int
at: src.models.user.contribs.RepoContributionStats
private: bool
contribs_count: int
commits_count: int
issues_count: int
prs_count: int
reviews_count: int
repos_count: int
other_count: int
languages: Dict[str, Language]
at: src.models.user.contribs.UserContributions
total_stats: ContributionStats
public_stats: ContributionStats
total: List[ContributionDay]
public: List[ContributionDay]
repo_stats: Dict[str, RepoContributionStats]
repos: Dict[str, List[ContributionDay]]
at: src.models.user.package.UserPackage
contribs: UserContributions
at: typing
List = _alias(list, 1, inst=False, name='List')
|
backend.src.svg.top_repos/get_top_repos_svg
|
Modified
|
avgupta456~github-trends
|
69ec8cf9d25e689daf2cec98b071456cd20bee53
|
show commits excluded
|
<0>:<add> subheader = time_str
<add> if commits_excluded > 50:
<add> subheader += " | " + str(commits_excluded) + " commits excluded"
<add>
<5>:<add> subheader_text=subheader,
<del> subheader_text=time_str,
|
# module: backend.src.svg.top_repos
def get_top_repos_svg(
+ data: List[RepoStats], time_str: str, commits_excluded: int
- data: List[RepoStats], time_str: str, include_private: bool
) -> Drawing:
<0> d, dp = get_template(
<1> width=300,
<2> height=285,
<3> padding=20,
<4> header_text="Most Contributed Repositories",
<5> subheader_text=time_str,
<6> debug=False,
<7> )
<8>
<9> dataset: List[Tuple[str, str, List[Tuple[float, str]]]] = []
<10> total = data[0].changed
<11> for x in data[:5]:
<12> data_row = []
<13> for j, lang in enumerate(x.langs):
<14> data_row.append(
<15> (100 * (lang.additions + lang.deletions) / total, lang.color)
<16> )
<17> dataset.append((x.repo, format_number(x.changed), data_row))
<18>
<19> section = get_bar_section(d=d, dataset=dataset, padding=45, bar_width=195)
<20>
<21> dp.add(section)
<22> d.add(dp)
<23> return d
<24>
|
===========unchanged ref 0===========
at: src.models.user.analytics.RepoLanguage
lang: str
color: str
additions: int
deletions: int
at: src.models.user.analytics.RepoStats
repo: str
langs: List[RepoLanguage]
additions: int
deletions: int
added: int
changed: int
at: src.svg.template
format_number(num: int) -> str
get_template(width: int, height: int, padding: int, header_text: str, subheader_text: str, debug: bool=False) -> Tuple[Drawing, Group]
get_bar_section(d: Drawing, dataset: List[Tuple[str, str, List[Tuple[float, str]]]], padding: int=45, bar_width: int=210) -> Group
at: typing
Tuple = _TupleType(tuple, -1, inst=False, name='Tuple')
List = _alias(list, 1, inst=False, name='List')
|
backend.src.routers.users.svg/get_user_lang_svg
|
Modified
|
avgupta456~github-trends
|
69ec8cf9d25e689daf2cec98b071456cd20bee53
|
show commits excluded
|
<4>:<add> processed, commits_excluded = get_top_languages(output, include_private)
<del> processed = get_top_languages(output, include_private)
<5>:<add> out = get_top_langs_svg(processed, time_str, use_percent, commits_excluded)
<del> out = get_top_langs_svg(processed, time_str, use_percent, include_private)
|
<s>_fail_gracefully
async def get_user_lang_svg(
response: Response,
user_id: str,
start_date: date = date.today() - timedelta(365),
end_date: date = date.today(),
time_range: str = "one_year",
timezone_str: str = "US/Eastern",
use_percent: bool = False,
+ include_private: bool = False,
- include_private: bool = True,
) -> Any:
<0> start_date, end_date, time_str = use_time_range(time_range, start_date, end_date)
<1> output = await get_user(user_id, start_date, end_date)
<2> if output is None:
<3> return get_loading_svg()
<4> processed = get_top_languages(output, include_private)
<5> out = get_top_langs_svg(processed, time_str, use_percent, include_private)
<6> return out
<7>
|
===========unchanged ref 0===========
at: backend.src.routers.users.svg
router = APIRouter()
at: datetime
timedelta(days: float=..., seconds: float=..., microseconds: float=..., milliseconds: float=..., minutes: float=..., hours: float=..., weeks: float=..., *, fold: int=...)
date()
at: datetime.date
__slots__ = '_year', '_month', '_day', '_hashcode'
today() -> _S
__str__ = isoformat
__radd__ = __add__
at: src.analytics.user.commits
get_top_languages(data: UserPackage, include_private: bool) -> Tuple[List[LanguageStats], int]
at: src.routers.users.get_data
get_user(user_id: str, start_date: date, end_date: date) -> Optional[UserPackage]
at: src.svg.error
get_loading_svg() -> Drawing
at: src.svg.top_langs
get_top_langs_svg(data: List[LanguageStats], time_str: str, use_percent: bool, commits_excluded: int) -> Drawing
at: src.utils
svg_fail_gracefully(func: Callable[..., Any])
use_time_range(time_range: str, start_date: date, end_date: date) -> Tuple[date, date, str]
===========changed ref 0===========
# module: backend.src.svg.top_repos
def get_top_repos_svg(
+ data: List[RepoStats], time_str: str, commits_excluded: int
- data: List[RepoStats], time_str: str, include_private: bool
) -> Drawing:
+ subheader = time_str
+ if commits_excluded > 50:
+ subheader += " | " + str(commits_excluded) + " commits excluded"
+
d, dp = get_template(
width=300,
height=285,
padding=20,
header_text="Most Contributed Repositories",
+ subheader_text=subheader,
- subheader_text=time_str,
debug=False,
)
dataset: List[Tuple[str, str, List[Tuple[float, str]]]] = []
total = data[0].changed
for x in data[:5]:
data_row = []
for j, lang in enumerate(x.langs):
data_row.append(
(100 * (lang.additions + lang.deletions) / total, lang.color)
)
dataset.append((x.repo, format_number(x.changed), data_row))
section = get_bar_section(d=d, dataset=dataset, padding=45, bar_width=195)
dp.add(section)
d.add(dp)
return d
|
backend.src.routers.users.svg/get_user_repo_svg
|
Modified
|
avgupta456~github-trends
|
69ec8cf9d25e689daf2cec98b071456cd20bee53
|
show commits excluded
|
<4>:<add> processed, commits_excluded = get_top_repos(output, include_private)
<del> processed = get_top_repos(output, include_private)
<5>:<add> return get_top_repos_svg(processed, time_str, commits_excluded)
<del> return get_top_repos_svg(processed, time_str, include_private)
|
<s>_class=HTMLResponse
)
@svg_fail_gracefully
async def get_user_repo_svg(
response: Response,
user_id: str,
start_date: date = date.today() - timedelta(365),
end_date: date = date.today(),
time_range: str = "one_year",
timezone_str: str = "US/Eastern",
+ include_private: bool = False,
- include_private: bool = True,
) -> Any:
<0> start_date, end_date, time_str = use_time_range(time_range, start_date, end_date)
<1> output = await get_user(user_id, start_date, end_date)
<2> if output is None:
<3> return get_loading_svg()
<4> processed = get_top_repos(output, include_private)
<5> return get_top_repos_svg(processed, time_str, include_private)
<6>
|
===========unchanged ref 0===========
at: backend.src.routers.users.svg
router = APIRouter()
at: datetime
timedelta(days: float=..., seconds: float=..., microseconds: float=..., milliseconds: float=..., minutes: float=..., hours: float=..., weeks: float=..., *, fold: int=...)
date()
at: datetime.date
today() -> _S
at: src.analytics.user.commits
get_top_repos(data: UserPackage, include_private: bool) -> Tuple[List[RepoStats], int]
at: src.routers.users.get_data
get_user(user_id: str, start_date: date, end_date: date) -> Optional[UserPackage]
at: src.svg.error
get_loading_svg() -> Drawing
at: src.svg.top_repos
get_top_repos_svg(data: List[RepoStats], time_str: str, commits_excluded: int) -> Drawing
at: src.utils
svg_fail_gracefully(func: Callable[..., Any])
use_time_range(time_range: str, start_date: date, end_date: date) -> Tuple[date, date, str]
===========changed ref 0===========
<s>_fail_gracefully
async def get_user_lang_svg(
response: Response,
user_id: str,
start_date: date = date.today() - timedelta(365),
end_date: date = date.today(),
time_range: str = "one_year",
timezone_str: str = "US/Eastern",
use_percent: bool = False,
+ include_private: bool = False,
- include_private: bool = True,
) -> Any:
start_date, end_date, time_str = use_time_range(time_range, start_date, end_date)
output = await get_user(user_id, start_date, end_date)
if output is None:
return get_loading_svg()
+ processed, commits_excluded = get_top_languages(output, include_private)
- processed = get_top_languages(output, include_private)
+ out = get_top_langs_svg(processed, time_str, use_percent, commits_excluded)
- out = get_top_langs_svg(processed, time_str, use_percent, include_private)
return out
===========changed ref 1===========
# module: backend.src.svg.top_repos
def get_top_repos_svg(
+ data: List[RepoStats], time_str: str, commits_excluded: int
- data: List[RepoStats], time_str: str, include_private: bool
) -> Drawing:
+ subheader = time_str
+ if commits_excluded > 50:
+ subheader += " | " + str(commits_excluded) + " commits excluded"
+
d, dp = get_template(
width=300,
height=285,
padding=20,
header_text="Most Contributed Repositories",
+ subheader_text=subheader,
- subheader_text=time_str,
debug=False,
)
dataset: List[Tuple[str, str, List[Tuple[float, str]]]] = []
total = data[0].changed
for x in data[:5]:
data_row = []
for j, lang in enumerate(x.langs):
data_row.append(
(100 * (lang.additions + lang.deletions) / total, lang.color)
)
dataset.append((x.repo, format_number(x.changed), data_row))
section = get_bar_section(d=d, dataset=dataset, padding=45, bar_width=195)
dp.add(section)
d.add(dp)
return d
|
backend.src.svg.top_langs/get_top_langs_svg
|
Modified
|
avgupta456~github-trends
|
69ec8cf9d25e689daf2cec98b071456cd20bee53
|
show commits excluded
|
<0>:<add> subheader = time_str
<add> if commits_excluded > 50:
<add> subheader += " | " + str(commits_excluded) + " commits excluded"
<add>
<5>:<add> subheader_text=subheader,
<del> subheader_text=time_str,
|
# module: backend.src.svg.top_langs
def get_top_langs_svg(
+ data: List[LanguageStats], time_str: str, use_percent: bool, commits_excluded: int
- data: List[LanguageStats], time_str: str, use_percent: bool, include_private: bool
) -> Drawing:
<0> d, dp = get_template(
<1> width=300,
<2> height=285,
<3> padding=20,
<4> header_text="Most Used Languages",
<5> subheader_text=time_str,
<6> debug=False,
<7> )
<8>
<9> dataset: List[Tuple[str, str, List[Tuple[float, str]]]] = []
<10> for x in data[1:6]:
<11> if use_percent:
<12> dataset.append((x.lang, str(x.percent) + "%", [(x.percent, x.color)]))
<13> else:
<14> percent = 100 * x.changed / data[1].changed
<15> dataset.append((x.lang, format_number(x.changed), [(percent, x.color)]))
<16>
<17> section = get_bar_section(
<18> d=d, dataset=dataset, padding=45, bar_width=210 if use_percent else 195
<19> )
<20>
<21> dp.add(section)
<22> d.add(dp)
<23> return d
<24>
|
===========unchanged ref 0===========
at: src.models.user.analytics.LanguageStats
lang: str
additions: int
deletions: int
added: int
changed: int
percent: float
color: Optional[str]
at: src.svg.template
format_number(num: int) -> str
get_template(width: int, height: int, padding: int, header_text: str, subheader_text: str, debug: bool=False) -> Tuple[Drawing, Group]
get_bar_section(d: Drawing, dataset: List[Tuple[str, str, List[Tuple[float, str]]]], padding: int=45, bar_width: int=210) -> Group
at: typing
Tuple = _TupleType(tuple, -1, inst=False, name='Tuple')
List = _alias(list, 1, inst=False, name='List')
===========changed ref 0===========
<s>_class=HTMLResponse
)
@svg_fail_gracefully
async def get_user_repo_svg(
response: Response,
user_id: str,
start_date: date = date.today() - timedelta(365),
end_date: date = date.today(),
time_range: str = "one_year",
timezone_str: str = "US/Eastern",
+ include_private: bool = False,
- include_private: bool = True,
) -> Any:
start_date, end_date, time_str = use_time_range(time_range, start_date, end_date)
output = await get_user(user_id, start_date, end_date)
if output is None:
return get_loading_svg()
+ processed, commits_excluded = get_top_repos(output, include_private)
- processed = get_top_repos(output, include_private)
+ return get_top_repos_svg(processed, time_str, commits_excluded)
- return get_top_repos_svg(processed, time_str, include_private)
===========changed ref 1===========
<s>_fail_gracefully
async def get_user_lang_svg(
response: Response,
user_id: str,
start_date: date = date.today() - timedelta(365),
end_date: date = date.today(),
time_range: str = "one_year",
timezone_str: str = "US/Eastern",
use_percent: bool = False,
+ include_private: bool = False,
- include_private: bool = True,
) -> Any:
start_date, end_date, time_str = use_time_range(time_range, start_date, end_date)
output = await get_user(user_id, start_date, end_date)
if output is None:
return get_loading_svg()
+ processed, commits_excluded = get_top_languages(output, include_private)
- processed = get_top_languages(output, include_private)
+ out = get_top_langs_svg(processed, time_str, use_percent, commits_excluded)
- out = get_top_langs_svg(processed, time_str, use_percent, include_private)
return out
===========changed ref 2===========
# module: backend.src.svg.top_repos
def get_top_repos_svg(
+ data: List[RepoStats], time_str: str, commits_excluded: int
- data: List[RepoStats], time_str: str, include_private: bool
) -> Drawing:
+ subheader = time_str
+ if commits_excluded > 50:
+ subheader += " | " + str(commits_excluded) + " commits excluded"
+
d, dp = get_template(
width=300,
height=285,
padding=20,
header_text="Most Contributed Repositories",
+ subheader_text=subheader,
- subheader_text=time_str,
debug=False,
)
dataset: List[Tuple[str, str, List[Tuple[float, str]]]] = []
total = data[0].changed
for x in data[:5]:
data_row = []
for j, lang in enumerate(x.langs):
data_row.append(
(100 * (lang.additions + lang.deletions) / total, lang.color)
)
dataset.append((x.repo, format_number(x.changed), data_row))
section = get_bar_section(d=d, dataset=dataset, padding=45, bar_width=195)
dp.add(section)
d.add(dp)
return d
|
backend.src.analytics.user.commits/get_top_languages
|
Modified
|
avgupta456~github-trends
|
69ec8cf9d25e689daf2cec98b071456cd20bee53
|
show commits excluded
|
# module: backend.src.analytics.user.commits
+ def get_top_languages(
+ data: UserPackage, include_private: bool
+ ) -> Tuple[List[LanguageStats], int]:
- def get_top_languages(data: UserPackage, include_private: bool) -> List[LanguageStats]:
<0> raw_languages = (
<1> data.contribs.total_stats.languages
<2> if include_private
<3> else data.contribs.public_stats.languages
<4> )
<5>
<6> languages_list: List[dict_type] = [
<7> {
<8> "lang": lang,
<9> "color": stats.color,
<10> "additions": stats.additions,
<11> "deletions": stats.deletions,
<12> }
<13> for lang, stats in raw_languages.items()
<14> ]
<15>
<16> total_additions = sum([int(lang["additions"]) for lang in languages_list])
<17> total_deletions = sum([int(lang["deletions"]) for lang in languages_list])
<18> total_changed = total_additions + total_deletions + 1 # avoids division by zero
<19> total: dict_type = {
<20> "lang": "Total",
<21> "additions": total_additions,
<22> "deletions": total_deletions,
<23> }
<24>
<25> languages_list = sorted(
<26> languages_list,
<27> key=lambda x: int(x["additions"]) + int(x["deletions"]),
<28> reverse=True,
<29> )
<30> other: dict_type = {
<31> "lang": "Other",
<32> "additions": 0,
<33> "deletions": 0,
<34> "color": "#ededed",
<35> }
<36> for language in languages_list[4:]:
<37> other["additions"] = int(other["additions"]) + int(language["additions"])
<38> other["deletions"] = int(other["deletions"]) + int(language["deletions"])
<39>
<40> languages_list = [total] +</s>
|
===========below chunk 0===========
# module: backend.src.analytics.user.commits
+ def get_top_languages(
+ data: UserPackage, include_private: bool
+ ) -> Tuple[List[LanguageStats], int]:
- def get_top_languages(data: UserPackage, include_private: bool) -> List[LanguageStats]:
# offset: 1
new_languages_list: List[LanguageStats] = []
for lang in languages_list:
lang["added"] = int(lang["additions"]) - int(lang["deletions"])
lang["changed"] = int(lang["additions"]) + int(lang["deletions"])
lang["percent"] = float(round(100 * lang["changed"] / total_changed, 2))
if lang["percent"] > 0:
new_languages_list.append(LanguageStats.parse_obj(lang))
return new_languages_list
===========unchanged ref 0===========
at: backend.src.analytics.user.commits
dict_type = Dict[str, Union[str, int, float]]
at: src.models.user.contribs.ContributionStats
contribs_count: int
commits_count: int
issues_count: int
prs_count: int
reviews_count: int
repos_count: int
other_count: int
languages: Dict[str, Language]
at: src.models.user.contribs.Language
color: str
additions: int
deletions: int
at: src.models.user.contribs.UserContributions
total_stats: ContributionStats
public_stats: ContributionStats
total: List[ContributionDay]
public: List[ContributionDay]
repo_stats: Dict[str, RepoContributionStats]
repos: Dict[str, List[ContributionDay]]
at: src.models.user.package.UserPackage
contribs: UserContributions
at: typing
Tuple = _TupleType(tuple, -1, inst=False, name='Tuple')
List = _alias(list, 1, inst=False, name='List')
===========changed ref 0===========
<s>_class=HTMLResponse
)
@svg_fail_gracefully
async def get_user_repo_svg(
response: Response,
user_id: str,
start_date: date = date.today() - timedelta(365),
end_date: date = date.today(),
time_range: str = "one_year",
timezone_str: str = "US/Eastern",
+ include_private: bool = False,
- include_private: bool = True,
) -> Any:
start_date, end_date, time_str = use_time_range(time_range, start_date, end_date)
output = await get_user(user_id, start_date, end_date)
if output is None:
return get_loading_svg()
+ processed, commits_excluded = get_top_repos(output, include_private)
- processed = get_top_repos(output, include_private)
+ return get_top_repos_svg(processed, time_str, commits_excluded)
- return get_top_repos_svg(processed, time_str, include_private)
===========changed ref 1===========
<s>_fail_gracefully
async def get_user_lang_svg(
response: Response,
user_id: str,
start_date: date = date.today() - timedelta(365),
end_date: date = date.today(),
time_range: str = "one_year",
timezone_str: str = "US/Eastern",
use_percent: bool = False,
+ include_private: bool = False,
- include_private: bool = True,
) -> Any:
start_date, end_date, time_str = use_time_range(time_range, start_date, end_date)
output = await get_user(user_id, start_date, end_date)
if output is None:
return get_loading_svg()
+ processed, commits_excluded = get_top_languages(output, include_private)
- processed = get_top_languages(output, include_private)
+ out = get_top_langs_svg(processed, time_str, use_percent, commits_excluded)
- out = get_top_langs_svg(processed, time_str, use_percent, include_private)
return out
===========changed ref 2===========
# module: backend.src.svg.top_repos
def get_top_repos_svg(
+ data: List[RepoStats], time_str: str, commits_excluded: int
- data: List[RepoStats], time_str: str, include_private: bool
) -> Drawing:
+ subheader = time_str
+ if commits_excluded > 50:
+ subheader += " | " + str(commits_excluded) + " commits excluded"
+
d, dp = get_template(
width=300,
height=285,
padding=20,
header_text="Most Contributed Repositories",
+ subheader_text=subheader,
- subheader_text=time_str,
debug=False,
)
dataset: List[Tuple[str, str, List[Tuple[float, str]]]] = []
total = data[0].changed
for x in data[:5]:
data_row = []
for j, lang in enumerate(x.langs):
data_row.append(
(100 * (lang.additions + lang.deletions) / total, lang.color)
)
dataset.append((x.repo, format_number(x.changed), data_row))
section = get_bar_section(d=d, dataset=dataset, padding=45, bar_width=195)
dp.add(section)
d.add(dp)
return d
===========changed ref 3===========
# module: backend.src.svg.top_langs
def get_top_langs_svg(
+ data: List[LanguageStats], time_str: str, use_percent: bool, commits_excluded: int
- data: List[LanguageStats], time_str: str, use_percent: bool, include_private: bool
) -> Drawing:
+ subheader = time_str
+ if commits_excluded > 50:
+ subheader += " | " + str(commits_excluded) + " commits excluded"
+
d, dp = get_template(
width=300,
height=285,
padding=20,
header_text="Most Used Languages",
+ subheader_text=subheader,
- subheader_text=time_str,
debug=False,
)
dataset: List[Tuple[str, str, List[Tuple[float, str]]]] = []
for x in data[1:6]:
if use_percent:
dataset.append((x.lang, str(x.percent) + "%", [(x.percent, x.color)]))
else:
percent = 100 * x.changed / data[1].changed
dataset.append((x.lang, format_number(x.changed), [(percent, x.color)]))
section = get_bar_section(
d=d, dataset=dataset, padding=45, bar_width=210 if use_percent else 195
)
dp.add(section)
d.add(dp)
return d
|
|
backend.src.analytics.user.commits/get_top_repos
|
Modified
|
avgupta456~github-trends
|
69ec8cf9d25e689daf2cec98b071456cd20bee53
|
show commits excluded
|
<36>:<add> commits_excluded = data.contribs.public_stats.other_count
<add> if include_private:
<add> commits_excluded = data.contribs.total_stats.other_count
<del> return new_repos[:5]
|
# module: backend.src.analytics.user.commits
+ def get_top_repos(
+ data: UserPackage, include_private: bool
+ ) -> Tuple[List[RepoStats], int]:
- def get_top_repos(data: UserPackage, include_private: bool) -> List[RepoStats]:
<0> repos: List[Any] = [
<1> {
<2> "repo": repo,
<3> "langs": [
<4> {
<5> "lang": x[0],
<6> "color": x[1].color,
<7> "additions": x[1].additions,
<8> "deletions": x[1].deletions,
<9> }
<10> for x in list(repo_stats.languages.items())
<11> ],
<12> "additions": sum([x.additions for x in repo_stats.languages.values()]),
<13> "deletions": sum([x.deletions for x in repo_stats.languages.values()]),
<14> }
<15> for repo, repo_stats in data.contribs.repo_stats.items()
<16> if include_private or not repo_stats.private
<17> ]
<18>
<19> for repo in repos:
<20> repo["added"] = int(repo["additions"]) - int(repo["deletions"])
<21> repo["changed"] = int(repo["additions"]) + int(repo["deletions"])
<22> repo["langs"] = [
<23> x
<24> for x in repo["langs"]
<25> if x["additions"] + x["deletions"] > 0.05 * repo["changed"]
<26> ]
<27>
<28> repos = sorted(repos, key=lambda x: x["changed"], reverse=True)
<29>
<30> new_repos = [
<31> RepoStats.parse_obj(x)
<32> for x in repos
<33> if x["changed"] > 0.01 * repos[0]["changed"]
<34> ]
<35>
<36> return new_repos[:5]
<37>
|
===========unchanged ref 0===========
at: backend.src.analytics.user.commits.get_top_languages
new_languages_list: List[LanguageStats] = []
at: src.models.user.contribs.ContributionStats
other_count: int
at: src.models.user.contribs.Language
color: str
additions: int
deletions: int
at: src.models.user.contribs.RepoContributionStats
private: bool
contribs_count: int
commits_count: int
issues_count: int
prs_count: int
reviews_count: int
repos_count: int
other_count: int
languages: Dict[str, Language]
at: src.models.user.contribs.UserContributions
total_stats: ContributionStats
repo_stats: Dict[str, RepoContributionStats]
at: src.models.user.package.UserPackage
contribs: UserContributions
at: typing
Tuple = _TupleType(tuple, -1, inst=False, name='Tuple')
List = _alias(list, 1, inst=False, name='List')
===========changed ref 0===========
# module: backend.src.analytics.user.commits
+ def get_top_languages(
+ data: UserPackage, include_private: bool
+ ) -> Tuple[List[LanguageStats], int]:
- def get_top_languages(data: UserPackage, include_private: bool) -> List[LanguageStats]:
raw_languages = (
data.contribs.total_stats.languages
if include_private
else data.contribs.public_stats.languages
)
languages_list: List[dict_type] = [
{
"lang": lang,
"color": stats.color,
"additions": stats.additions,
"deletions": stats.deletions,
}
for lang, stats in raw_languages.items()
]
total_additions = sum([int(lang["additions"]) for lang in languages_list])
total_deletions = sum([int(lang["deletions"]) for lang in languages_list])
total_changed = total_additions + total_deletions + 1 # avoids division by zero
total: dict_type = {
"lang": "Total",
"additions": total_additions,
"deletions": total_deletions,
}
languages_list = sorted(
languages_list,
key=lambda x: int(x["additions"]) + int(x["deletions"]),
reverse=True,
)
other: dict_type = {
"lang": "Other",
"additions": 0,
"deletions": 0,
"color": "#ededed",
}
for language in languages_list[4:]:
other["additions"] = int(other["additions"]) + int(language["additions"])
other["deletions"] = int(other["deletions"]) + int(language["deletions"])
languages_list = [total] + languages_list[:4] + [other]
new_languages_list: List[LanguageStats] = []
for lang in languages_list:
lang["added"]</s>
===========changed ref 1===========
# module: backend.src.analytics.user.commits
+ def get_top_languages(
+ data: UserPackage, include_private: bool
+ ) -> Tuple[List[LanguageStats], int]:
- def get_top_languages(data: UserPackage, include_private: bool) -> List[LanguageStats]:
# offset: 1
<s>
new_languages_list: List[LanguageStats] = []
for lang in languages_list:
lang["added"] = int(lang["additions"]) - int(lang["deletions"])
lang["changed"] = int(lang["additions"]) + int(lang["deletions"])
lang["percent"] = float(round(100 * lang["changed"] / total_changed, 2))
if lang["percent"] > 0:
new_languages_list.append(LanguageStats.parse_obj(lang))
+ commits_excluded = data.contribs.public_stats.other_count
+ if include_private:
+ commits_excluded = data.contribs.total_stats.other_count
- return new_languages_list
===========changed ref 2===========
<s>_class=HTMLResponse
)
@svg_fail_gracefully
async def get_user_repo_svg(
response: Response,
user_id: str,
start_date: date = date.today() - timedelta(365),
end_date: date = date.today(),
time_range: str = "one_year",
timezone_str: str = "US/Eastern",
+ include_private: bool = False,
- include_private: bool = True,
) -> Any:
start_date, end_date, time_str = use_time_range(time_range, start_date, end_date)
output = await get_user(user_id, start_date, end_date)
if output is None:
return get_loading_svg()
+ processed, commits_excluded = get_top_repos(output, include_private)
- processed = get_top_repos(output, include_private)
+ return get_top_repos_svg(processed, time_str, commits_excluded)
- return get_top_repos_svg(processed, time_str, include_private)
===========changed ref 3===========
<s>_fail_gracefully
async def get_user_lang_svg(
response: Response,
user_id: str,
start_date: date = date.today() - timedelta(365),
end_date: date = date.today(),
time_range: str = "one_year",
timezone_str: str = "US/Eastern",
use_percent: bool = False,
+ include_private: bool = False,
- include_private: bool = True,
) -> Any:
start_date, end_date, time_str = use_time_range(time_range, start_date, end_date)
output = await get_user(user_id, start_date, end_date)
if output is None:
return get_loading_svg()
+ processed, commits_excluded = get_top_languages(output, include_private)
- processed = get_top_languages(output, include_private)
+ out = get_top_langs_svg(processed, time_str, use_percent, commits_excluded)
- out = get_top_langs_svg(processed, time_str, use_percent, include_private)
return out
===========changed ref 4===========
# module: backend.src.svg.top_repos
def get_top_repos_svg(
+ data: List[RepoStats], time_str: str, commits_excluded: int
- data: List[RepoStats], time_str: str, include_private: bool
) -> Drawing:
+ subheader = time_str
+ if commits_excluded > 50:
+ subheader += " | " + str(commits_excluded) + " commits excluded"
+
d, dp = get_template(
width=300,
height=285,
padding=20,
header_text="Most Contributed Repositories",
+ subheader_text=subheader,
- subheader_text=time_str,
debug=False,
)
dataset: List[Tuple[str, str, List[Tuple[float, str]]]] = []
total = data[0].changed
for x in data[:5]:
data_row = []
for j, lang in enumerate(x.langs):
data_row.append(
(100 * (lang.additions + lang.deletions) / total, lang.color)
)
dataset.append((x.repo, format_number(x.changed), data_row))
section = get_bar_section(d=d, dataset=dataset, padding=45, bar_width=195)
dp.add(section)
d.add(dp)
return d
|
backend.src.svg.top_repos/get_top_repos_svg
|
Modified
|
avgupta456~github-trends
|
df1e8625e2b147d89d9eade4d7045573f91ffc82
|
hide repo name
|
<21>:<add> name = "Private Repository" if x.private else x.repo
<add> dataset.append((name, format_number(x.changed), data_row))
<del> dataset.append((x.repo, format_number(x.changed), data_row))
|
# module: backend.src.svg.top_repos
def get_top_repos_svg(
data: List[RepoStats], time_str: str, commits_excluded: int
) -> Drawing:
<0> subheader = time_str
<1> if commits_excluded > 50:
<2> subheader += " | " + str(commits_excluded) + " commits excluded"
<3>
<4> d, dp = get_template(
<5> width=300,
<6> height=285,
<7> padding=20,
<8> header_text="Most Contributed Repositories",
<9> subheader_text=subheader,
<10> debug=False,
<11> )
<12>
<13> dataset: List[Tuple[str, str, List[Tuple[float, str]]]] = []
<14> total = data[0].changed
<15> for x in data[:5]:
<16> data_row = []
<17> for j, lang in enumerate(x.langs):
<18> data_row.append(
<19> (100 * (lang.additions + lang.deletions) / total, lang.color)
<20> )
<21> dataset.append((x.repo, format_number(x.changed), data_row))
<22>
<23> section = get_bar_section(d=d, dataset=dataset, padding=45, bar_width=195)
<24>
<25> dp.add(section)
<26> d.add(dp)
<27> return d
<28>
|
===========unchanged ref 0===========
at: src.models.user.analytics.RepoLanguage
lang: str
color: str
additions: int
deletions: int
at: src.models.user.analytics.RepoStats
repo: str
private: bool
langs: List[RepoLanguage]
additions: int
deletions: int
added: int
changed: int
at: src.svg.template
format_number(num: int) -> str
get_template(width: int, height: int, padding: int, header_text: str, subheader_text: str, debug: bool=False) -> Tuple[Drawing, Group]
get_bar_section(d: Drawing, dataset: List[Tuple[str, str, List[Tuple[float, str]]]], padding: int=45, bar_width: int=210) -> Group
at: typing
Tuple = _TupleType(tuple, -1, inst=False, name='Tuple')
List = _alias(list, 1, inst=False, name='List')
|
backend.src.analytics.user.commits/get_top_repos
|
Modified
|
avgupta456~github-trends
|
df1e8625e2b147d89d9eade4d7045573f91ffc82
|
hide repo name
|
<3>:<add> "private": repo_stats.private,
|
# module: backend.src.analytics.user.commits
def get_top_repos(
data: UserPackage, include_private: bool
) -> Tuple[List[RepoStats], int]:
<0> repos: List[Any] = [
<1> {
<2> "repo": repo,
<3> "langs": [
<4> {
<5> "lang": x[0],
<6> "color": x[1].color,
<7> "additions": x[1].additions,
<8> "deletions": x[1].deletions,
<9> }
<10> for x in list(repo_stats.languages.items())
<11> ],
<12> "additions": sum([x.additions for x in repo_stats.languages.values()]),
<13> "deletions": sum([x.deletions for x in repo_stats.languages.values()]),
<14> }
<15> for repo, repo_stats in data.contribs.repo_stats.items()
<16> if include_private or not repo_stats.private
<17> ]
<18>
<19> for repo in repos:
<20> repo["added"] = int(repo["additions"]) - int(repo["deletions"])
<21> repo["changed"] = int(repo["additions"]) + int(repo["deletions"])
<22> repo["langs"] = [
<23> x
<24> for x in repo["langs"]
<25> if x["additions"] + x["deletions"] > 0.05 * repo["changed"]
<26> ]
<27>
<28> repos = sorted(repos, key=lambda x: x["changed"], reverse=True)
<29>
<30> new_repos = [
<31> RepoStats.parse_obj(x)
<32> for x in repos
<33> if x["changed"] > 0.01 * repos[0]["changed"]
<34> ]
<35>
<36> commits_excluded = data.contribs.public_stats.other_count
<37> if include_private:
<38> commits_excluded = data.contribs.total_stats.other_count
<39>
<40> return new_repos[:5], commits_excluded
<41>
|
===========unchanged ref 0===========
at: src.models.user.contribs.ContributionStats
contribs_count: int
commits_count: int
issues_count: int
prs_count: int
reviews_count: int
repos_count: int
other_count: int
languages: Dict[str, Language]
at: src.models.user.contribs.Language
color: str
additions: int
deletions: int
at: src.models.user.contribs.RepoContributionStats
private: bool
contribs_count: int
commits_count: int
issues_count: int
prs_count: int
reviews_count: int
repos_count: int
other_count: int
languages: Dict[str, Language]
at: src.models.user.contribs.UserContributions
total_stats: ContributionStats
public_stats: ContributionStats
total: List[ContributionDay]
public: List[ContributionDay]
repo_stats: Dict[str, RepoContributionStats]
repos: Dict[str, List[ContributionDay]]
at: src.models.user.package.UserPackage
contribs: UserContributions
at: typing
Tuple = _TupleType(tuple, -1, inst=False, name='Tuple')
List = _alias(list, 1, inst=False, name='List')
===========changed ref 0===========
# module: backend.src.models.user.analytics
class RepoStats(BaseModel):
repo: str
+ private: bool
langs: List[RepoLanguage]
additions: int
deletions: int
added: int
changed: int
===========changed ref 1===========
# module: backend.src.svg.top_repos
def get_top_repos_svg(
data: List[RepoStats], time_str: str, commits_excluded: int
) -> Drawing:
subheader = time_str
if commits_excluded > 50:
subheader += " | " + str(commits_excluded) + " commits excluded"
d, dp = get_template(
width=300,
height=285,
padding=20,
header_text="Most Contributed Repositories",
subheader_text=subheader,
debug=False,
)
dataset: List[Tuple[str, str, List[Tuple[float, str]]]] = []
total = data[0].changed
for x in data[:5]:
data_row = []
for j, lang in enumerate(x.langs):
data_row.append(
(100 * (lang.additions + lang.deletions) / total, lang.color)
)
+ name = "Private Repository" if x.private else x.repo
+ dataset.append((name, format_number(x.changed), data_row))
- dataset.append((x.repo, format_number(x.changed), data_row))
section = get_bar_section(d=d, dataset=dataset, padding=45, bar_width=195)
dp.add(section)
d.add(dp)
return d
|
backend.src.svg.top_repos/get_top_repos_svg
|
Modified
|
avgupta456~github-trends
|
e187ba01d289d7ff6088274f85eb0cee97b3c177
|
loc_metric option backend
|
<1>:<add> subheader += " | " + ("LOC Changed" if loc_metric == "changed" else "LOC Added")
<14>:<add> total = data[0].loc
<del> total = data[0].changed
<18>:<del> data_row.append(
<19>:<del> (100 * (lang.additions + lang.deletions) / total, lang.color)
<20>:<del> )
<21>:<add> data_row.append((100 * lang.loc / total, lang.color))
<add> name = "private/repository" if x.private else x.repo
<del> name = "Private Repository" if x.private else x.repo
<22>:<add> dataset.append((name, format_number(x.loc), data_row))
<del> dataset.append((name, format_number(x.changed), data_row))
|
# module: backend.src.svg.top_repos
def get_top_repos_svg(
+ data: List[RepoStats], time_str: str, loc_metric: str, commits_excluded: int
- data: List[RepoStats], time_str: str, commits_excluded: int
) -> Drawing:
<0> subheader = time_str
<1> if commits_excluded > 50:
<2> subheader += " | " + str(commits_excluded) + " commits excluded"
<3>
<4> d, dp = get_template(
<5> width=300,
<6> height=285,
<7> padding=20,
<8> header_text="Most Contributed Repositories",
<9> subheader_text=subheader,
<10> debug=False,
<11> )
<12>
<13> dataset: List[Tuple[str, str, List[Tuple[float, str]]]] = []
<14> total = data[0].changed
<15> for x in data[:5]:
<16> data_row = []
<17> for j, lang in enumerate(x.langs):
<18> data_row.append(
<19> (100 * (lang.additions + lang.deletions) / total, lang.color)
<20> )
<21> name = "Private Repository" if x.private else x.repo
<22> dataset.append((name, format_number(x.changed), data_row))
<23>
<24> section = get_bar_section(d=d, dataset=dataset, padding=45, bar_width=195)
<25>
<26> dp.add(section)
<27> d.add(dp)
<28> return d
<29>
|
===========unchanged ref 0===========
at: src.models.user.analytics.RepoLanguage
lang: str
color: str
loc: int
at: src.models.user.analytics.RepoStats
repo: str
private: bool
langs: List[RepoLanguage]
loc: int
at: src.svg.template
format_number(num: int) -> str
get_template(width: int, height: int, padding: int, header_text: str, subheader_text: str, debug: bool=False) -> Tuple[Drawing, Group]
get_bar_section(d: Drawing, dataset: List[Tuple[str, str, List[Tuple[float, str]]]], padding: int=45, bar_width: int=210) -> Group
at: typing
Tuple = _TupleType(tuple, -1, inst=False, name='Tuple')
List = _alias(list, 1, inst=False, name='List')
|
backend.src.svg.template/get_template
|
Modified
|
avgupta456~github-trends
|
e187ba01d289d7ff6088274f85eb0cee97b3c177
|
loc_metric option backend
|
<24>:<add> dp.add(d.text(subheader_text, insert=(0, 31), class_="subheader"))
<del> dp.add(d.text(subheader_text, insert=(0, 33), class_="subheader"))
|
# module: backend.src.svg.template
def get_template(
width: int,
height: int,
padding: int,
header_text: str,
subheader_text: str,
debug: bool = False,
) -> Tuple[Drawing, Group]:
<0> d = Drawing(size=(width, height))
<1> d.defs.add(d.style(style))
<2>
<3> d.add(
<4> d.rect(
<5> size=(width - 1, height - 1),
<6> insert=(0.5, 0.5),
<7> rx=4.5,
<8> stroke="#e4e2e2",
<9> fill="#fffefe",
<10> )
<11> )
<12>
<13> d.add(
<14> d.rect(
<15> size=(width - 2 * padding, height - 2 * padding),
<16> insert=(padding, padding),
<17> fill="#eee" if debug else "#fff",
<18> )
<19> )
<20>
<21> dp = Group(transform="translate(" + str(padding) + ", " + str(padding) + ")")
<22>
<23> dp.add(d.text(header_text, insert=(0, 13), class_="header"))
<24> dp.add(d.text(subheader_text, insert=(0, 33), class_="subheader"))
<25>
<26> return d, dp
<27>
|
===========unchanged ref 0===========
at: src.svg.style
style = """
.header {
font: 600 18px 'Segoe UI', Ubuntu, Sans-Serif;
fill: #2f80ed;
animation: fadeInAnimation 0.8s ease-in-out forwards;
}
.subheader {
font: 500 10px 'Segoe UI', Ubuntu, San-Serif;
fill: #666;
animation: fadeInAnimation 0.8s ease-in-out forwards;
}
.lang-name {
font: 400 11px 'Segoe UI', Ubuntu, Sans-Serif;
fill: #333;
}
@keyframes fadeInAnimation {
from {
opacity: 0;
}
to {
opacity: 1;
}
}
"""
at: typing
Tuple = _TupleType(tuple, -1, inst=False, name='Tuple')
===========changed ref 0===========
# module: backend.src.svg.top_repos
def get_top_repos_svg(
+ data: List[RepoStats], time_str: str, loc_metric: str, commits_excluded: int
- data: List[RepoStats], time_str: str, commits_excluded: int
) -> Drawing:
subheader = time_str
+ subheader += " | " + ("LOC Changed" if loc_metric == "changed" else "LOC Added")
if commits_excluded > 50:
subheader += " | " + str(commits_excluded) + " commits excluded"
d, dp = get_template(
width=300,
height=285,
padding=20,
header_text="Most Contributed Repositories",
subheader_text=subheader,
debug=False,
)
dataset: List[Tuple[str, str, List[Tuple[float, str]]]] = []
+ total = data[0].loc
- total = data[0].changed
for x in data[:5]:
data_row = []
for j, lang in enumerate(x.langs):
- data_row.append(
- (100 * (lang.additions + lang.deletions) / total, lang.color)
- )
+ data_row.append((100 * lang.loc / total, lang.color))
+ name = "private/repository" if x.private else x.repo
- name = "Private Repository" if x.private else x.repo
+ dataset.append((name, format_number(x.loc), data_row))
- dataset.append((name, format_number(x.changed), data_row))
section = get_bar_section(d=d, dataset=dataset, padding=45, bar_width=195)
dp.add(section)
d.add(dp)
return d
|
backend.src.analytics.user.commits/get_top_languages
|
Modified
|
avgupta456~github-trends
|
e187ba01d289d7ff6088274f85eb0cee97b3c177
|
loc_metric option backend
|
<10>:<del> "additions": stats.additions,
<11>:<del> "deletions": stats.deletions,
<12>:<add> "loc": loc_metric_func(loc_metric, stats.additions, stats.deletions),
<16>:<del> total_additions = sum([int(lang["additions"]) for lang in languages_list])
<17>:<del> total_deletions = sum([int(lang["deletions"]) for lang in languages_list])
<18>:<del> total_changed = total_additions + total_deletions + 1 # avoids division by zero
<19>:<del> total: dict_type = {
<20>:<del> "lang": "Total",
<21>:<del> "additions": total_additions,
<22>:<del> "deletions": total_deletions,
<23>:<del> }
<24>:<add> languages_list = list(filter(lambda x: x["loc"] > 0, languages_list)) # type: ignore
<25>:<del> languages_list = sorted(
<26>:<del> languages_list,
<27>:<del> key=lambda x: int(x["additions"]) + int(x["deletions"]),
<28>:<del> reverse=True,
<29>:<del> )
<30>:<del> other: dict_type = {
<31>:<del> "lang": "Other",
<32>:<del> "additions": 0,
<33>:<del> "deletions": 0,
<34>:<del> "color": "#ededed",
<35>:<del> }
<36>:<add> total_loc: int = sum(x["loc"] for x in languages_list) # type: ignore
<add> total: dict_type = {"lang": "Total", "loc": total_loc + 1}
<add>
<add> languages_list = sorted(languages_list, key=lambda x: x["loc"], reverse=True)
<add> other: dict_type = {"lang": "Other", "loc": 0, "color": "#ededed"}
<37>:<del> other["additions"] = int(other["additions"]) + int(language["additions"])
<38>:<add> other["loc"] = int(other["loc"]) + int(language["loc"])
<del> other["deletions"] = int(other["deletions"]) + int(language["deletions"])
|
# module: backend.src.analytics.user.commits
def get_top_languages(
+ data: UserPackage, loc_metric: str, include_private: bool
- data: UserPackage, include_private: bool
) -> Tuple[List[LanguageStats], int]:
<0> raw_languages = (
<1> data.contribs.total_stats.languages
<2> if include_private
<3> else data.contribs.public_stats.languages
<4> )
<5>
<6> languages_list: List[dict_type] = [
<7> {
<8> "lang": lang,
<9> "color": stats.color,
<10> "additions": stats.additions,
<11> "deletions": stats.deletions,
<12> }
<13> for lang, stats in raw_languages.items()
<14> ]
<15>
<16> total_additions = sum([int(lang["additions"]) for lang in languages_list])
<17> total_deletions = sum([int(lang["deletions"]) for lang in languages_list])
<18> total_changed = total_additions + total_deletions + 1 # avoids division by zero
<19> total: dict_type = {
<20> "lang": "Total",
<21> "additions": total_additions,
<22> "deletions": total_deletions,
<23> }
<24>
<25> languages_list = sorted(
<26> languages_list,
<27> key=lambda x: int(x["additions"]) + int(x["deletions"]),
<28> reverse=True,
<29> )
<30> other: dict_type = {
<31> "lang": "Other",
<32> "additions": 0,
<33> "deletions": 0,
<34> "color": "#ededed",
<35> }
<36> for language in languages_list[4:]:
<37> other["additions"] = int(other["additions"]) + int(language["additions"])
<38> other["deletions"] = int(other["deletions"]) + int(language["deletions"])
<39>
<40> languages_list = [total] + languages_list[:4] + [other</s>
|
===========below chunk 0===========
# module: backend.src.analytics.user.commits
def get_top_languages(
+ data: UserPackage, loc_metric: str, include_private: bool
- data: UserPackage, include_private: bool
) -> Tuple[List[LanguageStats], int]:
# offset: 1
new_languages_list: List[LanguageStats] = []
for lang in languages_list:
lang["added"] = int(lang["additions"]) - int(lang["deletions"])
lang["changed"] = int(lang["additions"]) + int(lang["deletions"])
lang["percent"] = float(round(100 * lang["changed"] / total_changed, 2))
if lang["percent"] > 0:
new_languages_list.append(LanguageStats.parse_obj(lang))
commits_excluded = data.contribs.public_stats.other_count
if include_private:
commits_excluded = data.contribs.total_stats.other_count
return new_languages_list, commits_excluded
===========unchanged ref 0===========
at: backend.src.analytics.user.commits
dict_type = Dict[str, Union[str, int, float]]
repos: List[Any] = [
{
"repo": repo,
"private": repo_stats.private,
"langs": [
{
"lang": x[0],
"color": x[1].color,
"loc": loc_metric_func(loc_metric, x[1].additions, x[1].deletions),
}
for x in list(repo_stats.languages.items())
],
"loc": sum(
[
loc_metric_func(loc_metric, x.additions, x.deletions)
for x in repo_stats.languages.values()
]
),
}
for repo, repo_stats in data.contribs.repo_stats.items()
if include_private or not repo_stats.private
]
repos: List[Any] = [
{
"repo": repo,
"private": repo_stats.private,
"langs": [
{
"lang": x[0],
"color": x[1].color,
"loc": loc_metric_func(loc_metric, x[1].additions, x[1].deletions),
}
for x in list(repo_stats.languages.items())
],
"loc": sum(
[
loc_metric_func(loc_metric, x.additions, x.deletions)
for x in repo_stats.languages.values()
]
),
}
for repo, repo_stats in data.contribs.repo_stats.items()
if include_private or not repo_stats.private
]
at: src.models.user.contribs.ContributionStats
contribs_count: int
commits_count: int
issues_count: int
prs_count: int
reviews_count: int
repos_count: int
===========unchanged ref 1===========
other_count: int
languages: Dict[str, Language]
at: src.models.user.contribs.Language
color: str
additions: int
deletions: int
at: src.models.user.contribs.RepoContributionStats
private: bool
contribs_count: int
commits_count: int
issues_count: int
prs_count: int
reviews_count: int
repos_count: int
other_count: int
languages: Dict[str, Language]
at: src.models.user.contribs.UserContributions
total_stats: ContributionStats
public_stats: ContributionStats
total: List[ContributionDay]
public: List[ContributionDay]
repo_stats: Dict[str, RepoContributionStats]
repos: Dict[str, List[ContributionDay]]
at: src.models.user.package.UserPackage
contribs: UserContributions
at: typing
Tuple = _TupleType(tuple, -1, inst=False, name='Tuple')
List = _alias(list, 1, inst=False, name='List')
===========changed ref 0===========
# module: backend.src.analytics.user.commits
+ def loc_metric_func(loc_metric: str, additions: int, deletions: int) -> int:
+ if loc_metric == "changed":
+ return additions + deletions
+ return additions - deletions
+
===========changed ref 1===========
# module: backend.src.svg.style
style = """
.header {
font: 600 18px 'Segoe UI', Ubuntu, Sans-Serif;
fill: #2f80ed;
animation: fadeInAnimation 0.8s ease-in-out forwards;
}
.subheader {
+ font: 500 10px 'Segoe UI', Ubuntu, San-Serif;
- font: 500 13px 'Segoe UI', Ubuntu, San-Serif;
fill: #666;
animation: fadeInAnimation 0.8s ease-in-out forwards;
}
.lang-name {
font: 400 11px 'Segoe UI', Ubuntu, Sans-Serif;
fill: #333;
}
@keyframes fadeInAnimation {
from {
opacity: 0;
}
to {
opacity: 1;
}
}
"""
===========changed ref 2===========
# module: backend.src.svg.template
def get_template(
width: int,
height: int,
padding: int,
header_text: str,
subheader_text: str,
debug: bool = False,
) -> Tuple[Drawing, Group]:
d = Drawing(size=(width, height))
d.defs.add(d.style(style))
d.add(
d.rect(
size=(width - 1, height - 1),
insert=(0.5, 0.5),
rx=4.5,
stroke="#e4e2e2",
fill="#fffefe",
)
)
d.add(
d.rect(
size=(width - 2 * padding, height - 2 * padding),
insert=(padding, padding),
fill="#eee" if debug else "#fff",
)
)
dp = Group(transform="translate(" + str(padding) + ", " + str(padding) + ")")
dp.add(d.text(header_text, insert=(0, 13), class_="header"))
+ dp.add(d.text(subheader_text, insert=(0, 31), class_="subheader"))
- dp.add(d.text(subheader_text, insert=(0, 33), class_="subheader"))
return d, dp
|
backend.src.analytics.user.commits/get_top_repos
|
Modified
|
avgupta456~github-trends
|
e187ba01d289d7ff6088274f85eb0cee97b3c177
|
loc_metric option backend
|
<8>:<del> "additions": x[1].additions,
<9>:<del> "deletions": x[1].deletions,
<10>:<add> "loc": loc_metric_func(loc_metric, x[1].additions, x[1].deletions),
<13>:<add> "loc": sum(
<add> [
<add> loc_metric_func(loc_metric, x.additions, x.deletions)
<add> for x in repo_stats.languages.values()
<add> ]
<add> ),
<del> "additions": sum([x.additions for x in repo_stats.languages.values()]),
<14>:<del> "deletions": sum([x.deletions for x in repo_stats.languages.values()]),
<20>:<add> repos = list(filter(lambda x: x["loc"] > 0, repos))
<21>:<del> repo["added"] = int(repo["additions"]) - int(repo["deletions"])
<22>:<del> repo["changed"] = int(repo["additions"]) + int(repo["deletions"])
<23>:<del> repo["langs"] = [
<24>:<del> x
<25>:<del> for x in repo["langs"]
<26>:<del> if x["additions"] + x["deletions"] > 0.05 * repo["changed"]
<27>:<del> ]
<28>:<del>
<29>:<add> repo["langs"] = [x for x in repo["langs"] if x["loc"] > 0.05 * repo["loc"]]
<add> repos = sorted(repos, key=lambda x: x["loc"], reverse=True)
<del> repos = sorted(repos, key=lambda x: x["changed"], reverse=True)
<32>:<del> RepoStats.parse_obj(x)
<33>:<del> for x in repos
<34>:<del> if x["changed"] > 0.01 * repos[0]["changed"]
<35>:<add> RepoStats.parse_obj(x) for x in repos if x["loc"] > 0.01 * repos[0]["loc"]
|
# module: backend.src.analytics.user.commits
def get_top_repos(
+ data: UserPackage, loc_metric: str, include_private: bool
- data: UserPackage, include_private: bool
) -> Tuple[List[RepoStats], int]:
<0> repos: List[Any] = [
<1> {
<2> "repo": repo,
<3> "private": repo_stats.private,
<4> "langs": [
<5> {
<6> "lang": x[0],
<7> "color": x[1].color,
<8> "additions": x[1].additions,
<9> "deletions": x[1].deletions,
<10> }
<11> for x in list(repo_stats.languages.items())
<12> ],
<13> "additions": sum([x.additions for x in repo_stats.languages.values()]),
<14> "deletions": sum([x.deletions for x in repo_stats.languages.values()]),
<15> }
<16> for repo, repo_stats in data.contribs.repo_stats.items()
<17> if include_private or not repo_stats.private
<18> ]
<19>
<20> for repo in repos:
<21> repo["added"] = int(repo["additions"]) - int(repo["deletions"])
<22> repo["changed"] = int(repo["additions"]) + int(repo["deletions"])
<23> repo["langs"] = [
<24> x
<25> for x in repo["langs"]
<26> if x["additions"] + x["deletions"] > 0.05 * repo["changed"]
<27> ]
<28>
<29> repos = sorted(repos, key=lambda x: x["changed"], reverse=True)
<30>
<31> new_repos = [
<32> RepoStats.parse_obj(x)
<33> for x in repos
<34> if x["changed"] > 0.01 * repos[0]["changed"]
<35> ]
<36>
<37> commits_excluded = data.contribs.public_stats.other_count
<38> if include_private:
<39> commits_excluded = data.contrib</s>
|
===========below chunk 0===========
# module: backend.src.analytics.user.commits
def get_top_repos(
+ data: UserPackage, loc_metric: str, include_private: bool
- data: UserPackage, include_private: bool
) -> Tuple[List[RepoStats], int]:
# offset: 1
return new_repos[:5], commits_excluded
===========unchanged ref 0===========
at: backend.src.analytics.user.commits
loc_metric_func(loc_metric: str, additions: int, deletions: int) -> int
at: src.models.user.contribs.ContributionStats
other_count: int
at: src.models.user.contribs.Language
additions: int
deletions: int
at: src.models.user.contribs.RepoContributionStats
languages: Dict[str, Language]
at: src.models.user.contribs.UserContributions
total_stats: ContributionStats
public_stats: ContributionStats
repo_stats: Dict[str, RepoContributionStats]
at: src.models.user.package.UserPackage
contribs: UserContributions
===========changed ref 0===========
# module: backend.src.analytics.user.commits
+ def loc_metric_func(loc_metric: str, additions: int, deletions: int) -> int:
+ if loc_metric == "changed":
+ return additions + deletions
+ return additions - deletions
+
===========changed ref 1===========
# module: backend.src.analytics.user.commits
def get_top_languages(
+ data: UserPackage, loc_metric: str, include_private: bool
- data: UserPackage, include_private: bool
) -> Tuple[List[LanguageStats], int]:
raw_languages = (
data.contribs.total_stats.languages
if include_private
else data.contribs.public_stats.languages
)
languages_list: List[dict_type] = [
{
"lang": lang,
"color": stats.color,
- "additions": stats.additions,
- "deletions": stats.deletions,
+ "loc": loc_metric_func(loc_metric, stats.additions, stats.deletions),
}
for lang, stats in raw_languages.items()
]
- total_additions = sum([int(lang["additions"]) for lang in languages_list])
- total_deletions = sum([int(lang["deletions"]) for lang in languages_list])
- total_changed = total_additions + total_deletions + 1 # avoids division by zero
- total: dict_type = {
- "lang": "Total",
- "additions": total_additions,
- "deletions": total_deletions,
- }
+ languages_list = list(filter(lambda x: x["loc"] > 0, languages_list)) # type: ignore
- languages_list = sorted(
- languages_list,
- key=lambda x: int(x["additions"]) + int(x["deletions"]),
- reverse=True,
- )
- other: dict_type = {
- "lang": "Other",
- "additions": 0,
- "deletions": 0,
- "color": "#ededed",
- }
+ total_loc: int = sum(x["loc"] for x in languages_list) # type: ignore
+ total: dict_type = {"lang": "Total", "loc": total</s>
===========changed ref 2===========
# module: backend.src.analytics.user.commits
def get_top_languages(
+ data: UserPackage, loc_metric: str, include_private: bool
- data: UserPackage, include_private: bool
) -> Tuple[List[LanguageStats], int]:
# offset: 1
<s> x in languages_list) # type: ignore
+ total: dict_type = {"lang": "Total", "loc": total_loc + 1}
+
+ languages_list = sorted(languages_list, key=lambda x: x["loc"], reverse=True)
+ other: dict_type = {"lang": "Other", "loc": 0, "color": "#ededed"}
for language in languages_list[4:]:
- other["additions"] = int(other["additions"]) + int(language["additions"])
+ other["loc"] = int(other["loc"]) + int(language["loc"])
- other["deletions"] = int(other["deletions"]) + int(language["deletions"])
languages_list = [total] + languages_list[:4] + [other]
new_languages_list: List[LanguageStats] = []
for lang in languages_list:
- lang["added"] = int(lang["additions"]) - int(lang["deletions"])
- lang["changed"] = int(lang["additions"]) + int(lang["deletions"])
+ lang["percent"] = float(round(100 * int(lang["loc"]) / total_loc, 2))
- lang["percent"] = float(round(100 * lang["changed"] / total_changed, 2))
+ if lang["percent"] > 1: # 1% minimum to show
- if lang["percent"] > 0:
new_languages_list.append(LanguageStats.parse_obj(lang))
commits_excluded = data.contribs.public_stats.other_count
if include_private:
commits_excluded =
===========changed ref 3===========
# module: backend.src.svg.style
style = """
.header {
font: 600 18px 'Segoe UI', Ubuntu, Sans-Serif;
fill: #2f80ed;
animation: fadeInAnimation 0.8s ease-in-out forwards;
}
.subheader {
+ font: 500 10px 'Segoe UI', Ubuntu, San-Serif;
- font: 500 13px 'Segoe UI', Ubuntu, San-Serif;
fill: #666;
animation: fadeInAnimation 0.8s ease-in-out forwards;
}
.lang-name {
font: 400 11px 'Segoe UI', Ubuntu, Sans-Serif;
fill: #333;
}
@keyframes fadeInAnimation {
from {
opacity: 0;
}
to {
opacity: 1;
}
}
"""
===========changed ref 4===========
# module: backend.src.svg.template
def get_template(
width: int,
height: int,
padding: int,
header_text: str,
subheader_text: str,
debug: bool = False,
) -> Tuple[Drawing, Group]:
d = Drawing(size=(width, height))
d.defs.add(d.style(style))
d.add(
d.rect(
size=(width - 1, height - 1),
insert=(0.5, 0.5),
rx=4.5,
stroke="#e4e2e2",
fill="#fffefe",
)
)
d.add(
d.rect(
size=(width - 2 * padding, height - 2 * padding),
insert=(padding, padding),
fill="#eee" if debug else "#fff",
)
)
dp = Group(transform="translate(" + str(padding) + ", " + str(padding) + ")")
dp.add(d.text(header_text, insert=(0, 13), class_="header"))
+ dp.add(d.text(subheader_text, insert=(0, 31), class_="subheader"))
- dp.add(d.text(subheader_text, insert=(0, 33), class_="subheader"))
return d, dp
|
backend.src.routers.users.svg/get_user_lang_svg
|
Modified
|
avgupta456~github-trends
|
e187ba01d289d7ff6088274f85eb0cee97b3c177
|
loc_metric option backend
|
<4>:<add> processed, commits_excluded = get_top_languages(output, loc_metric, include_private)
<del> processed, commits_excluded = get_top_languages(output, include_private)
<5>:<add> out = get_top_langs_svg(
<add> processed, time_str, use_percent, loc_metric, commits_excluded
<del> out = get_top_langs_svg(processed, time_str, use_percent, commits_excluded)
<6>:<add> )
|
<s>_fail_gracefully
async def get_user_lang_svg(
response: Response,
user_id: str,
start_date: date = date.today() - timedelta(365),
end_date: date = date.today(),
time_range: str = "one_year",
timezone_str: str = "US/Eastern",
use_percent: bool = False,
include_private: bool = False,
+ loc_metric: str = "added",
) -> Any:
<0> start_date, end_date, time_str = use_time_range(time_range, start_date, end_date)
<1> output = await get_user(user_id, start_date, end_date)
<2> if output is None:
<3> return get_loading_svg()
<4> processed, commits_excluded = get_top_languages(output, include_private)
<5> out = get_top_langs_svg(processed, time_str, use_percent, commits_excluded)
<6> return out
<7>
|
===========unchanged ref 0===========
at: backend.src.routers.users.svg
router = APIRouter()
at: datetime
timedelta(days: float=..., seconds: float=..., microseconds: float=..., milliseconds: float=..., minutes: float=..., hours: float=..., weeks: float=..., *, fold: int=...)
date()
at: datetime.date
__slots__ = '_year', '_month', '_day', '_hashcode'
today() -> _S
__str__ = isoformat
__radd__ = __add__
at: src.analytics.user.commits
get_top_languages(data: UserPackage, loc_metric: str, include_private: bool) -> Tuple[List[LanguageStats], int]
at: src.routers.users.get_data
get_user(user_id: str, start_date: date, end_date: date) -> Optional[UserPackage]
at: src.svg.error
get_loading_svg() -> Drawing
at: src.svg.top_langs
get_top_langs_svg(data: List[LanguageStats], time_str: str, use_percent: bool, loc_metric: str, commits_excluded: int) -> Drawing
at: src.utils
svg_fail_gracefully(func: Callable[..., Any])
use_time_range(time_range: str, start_date: date, end_date: date) -> Tuple[date, date, str]
===========changed ref 0===========
# module: backend.src.analytics.user.commits
+ def loc_metric_func(loc_metric: str, additions: int, deletions: int) -> int:
+ if loc_metric == "changed":
+ return additions + deletions
+ return additions - deletions
+
===========changed ref 1===========
# module: backend.src.svg.style
style = """
.header {
font: 600 18px 'Segoe UI', Ubuntu, Sans-Serif;
fill: #2f80ed;
animation: fadeInAnimation 0.8s ease-in-out forwards;
}
.subheader {
+ font: 500 10px 'Segoe UI', Ubuntu, San-Serif;
- font: 500 13px 'Segoe UI', Ubuntu, San-Serif;
fill: #666;
animation: fadeInAnimation 0.8s ease-in-out forwards;
}
.lang-name {
font: 400 11px 'Segoe UI', Ubuntu, Sans-Serif;
fill: #333;
}
@keyframes fadeInAnimation {
from {
opacity: 0;
}
to {
opacity: 1;
}
}
"""
===========changed ref 2===========
# module: backend.src.svg.template
def get_template(
width: int,
height: int,
padding: int,
header_text: str,
subheader_text: str,
debug: bool = False,
) -> Tuple[Drawing, Group]:
d = Drawing(size=(width, height))
d.defs.add(d.style(style))
d.add(
d.rect(
size=(width - 1, height - 1),
insert=(0.5, 0.5),
rx=4.5,
stroke="#e4e2e2",
fill="#fffefe",
)
)
d.add(
d.rect(
size=(width - 2 * padding, height - 2 * padding),
insert=(padding, padding),
fill="#eee" if debug else "#fff",
)
)
dp = Group(transform="translate(" + str(padding) + ", " + str(padding) + ")")
dp.add(d.text(header_text, insert=(0, 13), class_="header"))
+ dp.add(d.text(subheader_text, insert=(0, 31), class_="subheader"))
- dp.add(d.text(subheader_text, insert=(0, 33), class_="subheader"))
return d, dp
===========changed ref 3===========
# module: backend.src.svg.top_repos
def get_top_repos_svg(
+ data: List[RepoStats], time_str: str, loc_metric: str, commits_excluded: int
- data: List[RepoStats], time_str: str, commits_excluded: int
) -> Drawing:
subheader = time_str
+ subheader += " | " + ("LOC Changed" if loc_metric == "changed" else "LOC Added")
if commits_excluded > 50:
subheader += " | " + str(commits_excluded) + " commits excluded"
d, dp = get_template(
width=300,
height=285,
padding=20,
header_text="Most Contributed Repositories",
subheader_text=subheader,
debug=False,
)
dataset: List[Tuple[str, str, List[Tuple[float, str]]]] = []
+ total = data[0].loc
- total = data[0].changed
for x in data[:5]:
data_row = []
for j, lang in enumerate(x.langs):
- data_row.append(
- (100 * (lang.additions + lang.deletions) / total, lang.color)
- )
+ data_row.append((100 * lang.loc / total, lang.color))
+ name = "private/repository" if x.private else x.repo
- name = "Private Repository" if x.private else x.repo
+ dataset.append((name, format_number(x.loc), data_row))
- dataset.append((name, format_number(x.changed), data_row))
section = get_bar_section(d=d, dataset=dataset, padding=45, bar_width=195)
dp.add(section)
d.add(dp)
return d
===========changed ref 4===========
# module: backend.src.analytics.user.commits
def get_top_repos(
+ data: UserPackage, loc_metric: str, include_private: bool
- data: UserPackage, include_private: bool
) -> Tuple[List[RepoStats], int]:
repos: List[Any] = [
{
"repo": repo,
"private": repo_stats.private,
"langs": [
{
"lang": x[0],
"color": x[1].color,
- "additions": x[1].additions,
- "deletions": x[1].deletions,
+ "loc": loc_metric_func(loc_metric, x[1].additions, x[1].deletions),
}
for x in list(repo_stats.languages.items())
],
+ "loc": sum(
+ [
+ loc_metric_func(loc_metric, x.additions, x.deletions)
+ for x in repo_stats.languages.values()
+ ]
+ ),
- "additions": sum([x.additions for x in repo_stats.languages.values()]),
- "deletions": sum([x.deletions for x in repo_stats.languages.values()]),
}
for repo, repo_stats in data.contribs.repo_stats.items()
if include_private or not repo_stats.private
]
+ repos = list(filter(lambda x: x["loc"] > 0, repos))
for repo in repos:
- repo["added"] = int(repo["additions"]) - int(repo["deletions"])
- repo["changed"] = int(repo["additions"]) + int(repo["deletions"])
- repo["langs"] = [
- x
- for x in repo["langs"]
- if x["additions"] + x["deletions"] > 0.05 * repo["changed"]
- ]
-
+ repo["langs"] = [x for x in repo["langs"] if x["loc</s>
|
backend.src.routers.users.svg/get_user_repo_svg
|
Modified
|
avgupta456~github-trends
|
e187ba01d289d7ff6088274f85eb0cee97b3c177
|
loc_metric option backend
|
<4>:<add> processed, commits_excluded = get_top_repos(output, loc_metric, include_private)
<del> processed, commits_excluded = get_top_repos(output, include_private)
<5>:<add> return get_top_repos_svg(processed, time_str, loc_metric, commits_excluded)
<del> return get_top_repos_svg(processed, time_str, commits_excluded)
|
<s>_class=HTMLResponse
)
@svg_fail_gracefully
async def get_user_repo_svg(
response: Response,
user_id: str,
start_date: date = date.today() - timedelta(365),
end_date: date = date.today(),
time_range: str = "one_year",
timezone_str: str = "US/Eastern",
include_private: bool = False,
+ loc_metric: str = "added",
) -> Any:
<0> start_date, end_date, time_str = use_time_range(time_range, start_date, end_date)
<1> output = await get_user(user_id, start_date, end_date)
<2> if output is None:
<3> return get_loading_svg()
<4> processed, commits_excluded = get_top_repos(output, include_private)
<5> return get_top_repos_svg(processed, time_str, commits_excluded)
<6>
|
===========unchanged ref 0===========
at: backend.src.routers.users.svg
router = APIRouter()
at: backend.src.routers.users.svg.get_user_lang_svg
out = get_top_langs_svg(
processed, time_str, use_percent, loc_metric, commits_excluded
)
at: datetime
timedelta(days: float=..., seconds: float=..., microseconds: float=..., milliseconds: float=..., minutes: float=..., hours: float=..., weeks: float=..., *, fold: int=...)
date()
at: datetime.date
today() -> _S
at: src.routers.users.get_data
get_user(user_id: str, start_date: date, end_date: date) -> Optional[UserPackage]
at: src.utils
svg_fail_gracefully(func: Callable[..., Any])
use_time_range(time_range: str, start_date: date, end_date: date) -> Tuple[date, date, str]
===========changed ref 0===========
<s>_fail_gracefully
async def get_user_lang_svg(
response: Response,
user_id: str,
start_date: date = date.today() - timedelta(365),
end_date: date = date.today(),
time_range: str = "one_year",
timezone_str: str = "US/Eastern",
use_percent: bool = False,
include_private: bool = False,
+ loc_metric: str = "added",
) -> Any:
start_date, end_date, time_str = use_time_range(time_range, start_date, end_date)
output = await get_user(user_id, start_date, end_date)
if output is None:
return get_loading_svg()
+ processed, commits_excluded = get_top_languages(output, loc_metric, include_private)
- processed, commits_excluded = get_top_languages(output, include_private)
+ out = get_top_langs_svg(
+ processed, time_str, use_percent, loc_metric, commits_excluded
- out = get_top_langs_svg(processed, time_str, use_percent, commits_excluded)
+ )
return out
===========changed ref 1===========
# module: backend.src.analytics.user.commits
+ def loc_metric_func(loc_metric: str, additions: int, deletions: int) -> int:
+ if loc_metric == "changed":
+ return additions + deletions
+ return additions - deletions
+
===========changed ref 2===========
# module: backend.src.svg.style
style = """
.header {
font: 600 18px 'Segoe UI', Ubuntu, Sans-Serif;
fill: #2f80ed;
animation: fadeInAnimation 0.8s ease-in-out forwards;
}
.subheader {
+ font: 500 10px 'Segoe UI', Ubuntu, San-Serif;
- font: 500 13px 'Segoe UI', Ubuntu, San-Serif;
fill: #666;
animation: fadeInAnimation 0.8s ease-in-out forwards;
}
.lang-name {
font: 400 11px 'Segoe UI', Ubuntu, Sans-Serif;
fill: #333;
}
@keyframes fadeInAnimation {
from {
opacity: 0;
}
to {
opacity: 1;
}
}
"""
===========changed ref 3===========
# module: backend.src.svg.template
def get_template(
width: int,
height: int,
padding: int,
header_text: str,
subheader_text: str,
debug: bool = False,
) -> Tuple[Drawing, Group]:
d = Drawing(size=(width, height))
d.defs.add(d.style(style))
d.add(
d.rect(
size=(width - 1, height - 1),
insert=(0.5, 0.5),
rx=4.5,
stroke="#e4e2e2",
fill="#fffefe",
)
)
d.add(
d.rect(
size=(width - 2 * padding, height - 2 * padding),
insert=(padding, padding),
fill="#eee" if debug else "#fff",
)
)
dp = Group(transform="translate(" + str(padding) + ", " + str(padding) + ")")
dp.add(d.text(header_text, insert=(0, 13), class_="header"))
+ dp.add(d.text(subheader_text, insert=(0, 31), class_="subheader"))
- dp.add(d.text(subheader_text, insert=(0, 33), class_="subheader"))
return d, dp
===========changed ref 4===========
# module: backend.src.svg.top_repos
def get_top_repos_svg(
+ data: List[RepoStats], time_str: str, loc_metric: str, commits_excluded: int
- data: List[RepoStats], time_str: str, commits_excluded: int
) -> Drawing:
subheader = time_str
+ subheader += " | " + ("LOC Changed" if loc_metric == "changed" else "LOC Added")
if commits_excluded > 50:
subheader += " | " + str(commits_excluded) + " commits excluded"
d, dp = get_template(
width=300,
height=285,
padding=20,
header_text="Most Contributed Repositories",
subheader_text=subheader,
debug=False,
)
dataset: List[Tuple[str, str, List[Tuple[float, str]]]] = []
+ total = data[0].loc
- total = data[0].changed
for x in data[:5]:
data_row = []
for j, lang in enumerate(x.langs):
- data_row.append(
- (100 * (lang.additions + lang.deletions) / total, lang.color)
- )
+ data_row.append((100 * lang.loc / total, lang.color))
+ name = "private/repository" if x.private else x.repo
- name = "Private Repository" if x.private else x.repo
+ dataset.append((name, format_number(x.loc), data_row))
- dataset.append((name, format_number(x.changed), data_row))
section = get_bar_section(d=d, dataset=dataset, padding=45, bar_width=195)
dp.add(section)
d.add(dp)
return d
|
backend.src.svg.top_langs/get_top_langs_svg
|
Modified
|
avgupta456~github-trends
|
e187ba01d289d7ff6088274f85eb0cee97b3c177
|
loc_metric option backend
|
<1>:<add> if not use_percent:
<add> subheader += " | " + ("LOC Changed" if loc_metric == "changed" else "LOC Added")
<18>:<add> percent = 100 * x.loc / data[1].loc
<del> percent = 100 * x.changed / data[1].changed
<19>:<add> dataset.append((x.lang, format_number(x.loc), [(percent, x.color)]))
<del> dataset.append((x.lang, format_number(x.changed), [(percent, x.color)]))
|
# module: backend.src.svg.top_langs
def get_top_langs_svg(
+ data: List[LanguageStats],
+ time_str: str,
+ use_percent: bool,
+ loc_metric: str,
+ commits_excluded: int,
- data: List[LanguageStats], time_str: str, use_percent: bool, commits_excluded: int
) -> Drawing:
<0> subheader = time_str
<1> if commits_excluded > 50:
<2> subheader += " | " + str(commits_excluded) + " commits excluded"
<3>
<4> d, dp = get_template(
<5> width=300,
<6> height=285,
<7> padding=20,
<8> header_text="Most Used Languages",
<9> subheader_text=subheader,
<10> debug=False,
<11> )
<12>
<13> dataset: List[Tuple[str, str, List[Tuple[float, str]]]] = []
<14> for x in data[1:6]:
<15> if use_percent:
<16> dataset.append((x.lang, str(x.percent) + "%", [(x.percent, x.color)]))
<17> else:
<18> percent = 100 * x.changed / data[1].changed
<19> dataset.append((x.lang, format_number(x.changed), [(percent, x.color)]))
<20>
<21> section = get_bar_section(
<22> d=d, dataset=dataset, padding=45, bar_width=210 if use_percent else 195
<23> )
<24>
<25> dp.add(section)
<26> d.add(dp)
<27> return d
<28>
|
===========unchanged ref 0===========
at: src.models.user.analytics.LanguageStats
lang: str
loc: int
percent: float
color: Optional[str]
at: src.svg.template
format_number(num: int) -> str
get_template(width: int, height: int, padding: int, header_text: str, subheader_text: str, debug: bool=False) -> Tuple[Drawing, Group]
get_bar_section(d: Drawing, dataset: List[Tuple[str, str, List[Tuple[float, str]]]], padding: int=45, bar_width: int=210) -> Group
at: typing
Tuple = _TupleType(tuple, -1, inst=False, name='Tuple')
List = _alias(list, 1, inst=False, name='List')
===========changed ref 0===========
# module: backend.src.analytics.user.commits
+ def loc_metric_func(loc_metric: str, additions: int, deletions: int) -> int:
+ if loc_metric == "changed":
+ return additions + deletions
+ return additions - deletions
+
===========changed ref 1===========
# module: backend.src.models.user.analytics
class RepoLanguage(BaseModel):
lang: str
color: str
- additions: int
- deletions: int
+ loc: int
===========changed ref 2===========
# module: backend.src.models.user.analytics
class LanguageStats(BaseModel):
lang: str
- additions: int
- deletions: int
- added: int
- changed: int
+ loc: int
percent: float
color: Optional[str]
===========changed ref 3===========
# module: backend.src.models.user.analytics
class RepoStats(BaseModel):
repo: str
private: bool
langs: List[RepoLanguage]
- additions: int
- deletions: int
- added: int
- changed: int
+ loc: int
===========changed ref 4===========
<s>_class=HTMLResponse
)
@svg_fail_gracefully
async def get_user_repo_svg(
response: Response,
user_id: str,
start_date: date = date.today() - timedelta(365),
end_date: date = date.today(),
time_range: str = "one_year",
timezone_str: str = "US/Eastern",
include_private: bool = False,
+ loc_metric: str = "added",
) -> Any:
start_date, end_date, time_str = use_time_range(time_range, start_date, end_date)
output = await get_user(user_id, start_date, end_date)
if output is None:
return get_loading_svg()
+ processed, commits_excluded = get_top_repos(output, loc_metric, include_private)
- processed, commits_excluded = get_top_repos(output, include_private)
+ return get_top_repos_svg(processed, time_str, loc_metric, commits_excluded)
- return get_top_repos_svg(processed, time_str, commits_excluded)
===========changed ref 5===========
<s>_fail_gracefully
async def get_user_lang_svg(
response: Response,
user_id: str,
start_date: date = date.today() - timedelta(365),
end_date: date = date.today(),
time_range: str = "one_year",
timezone_str: str = "US/Eastern",
use_percent: bool = False,
include_private: bool = False,
+ loc_metric: str = "added",
) -> Any:
start_date, end_date, time_str = use_time_range(time_range, start_date, end_date)
output = await get_user(user_id, start_date, end_date)
if output is None:
return get_loading_svg()
+ processed, commits_excluded = get_top_languages(output, loc_metric, include_private)
- processed, commits_excluded = get_top_languages(output, include_private)
+ out = get_top_langs_svg(
+ processed, time_str, use_percent, loc_metric, commits_excluded
- out = get_top_langs_svg(processed, time_str, use_percent, commits_excluded)
+ )
return out
===========changed ref 6===========
# module: backend.src.svg.style
style = """
.header {
font: 600 18px 'Segoe UI', Ubuntu, Sans-Serif;
fill: #2f80ed;
animation: fadeInAnimation 0.8s ease-in-out forwards;
}
.subheader {
+ font: 500 10px 'Segoe UI', Ubuntu, San-Serif;
- font: 500 13px 'Segoe UI', Ubuntu, San-Serif;
fill: #666;
animation: fadeInAnimation 0.8s ease-in-out forwards;
}
.lang-name {
font: 400 11px 'Segoe UI', Ubuntu, Sans-Serif;
fill: #333;
}
@keyframes fadeInAnimation {
from {
opacity: 0;
}
to {
opacity: 1;
}
}
"""
===========changed ref 7===========
# module: backend.src.svg.template
def get_template(
width: int,
height: int,
padding: int,
header_text: str,
subheader_text: str,
debug: bool = False,
) -> Tuple[Drawing, Group]:
d = Drawing(size=(width, height))
d.defs.add(d.style(style))
d.add(
d.rect(
size=(width - 1, height - 1),
insert=(0.5, 0.5),
rx=4.5,
stroke="#e4e2e2",
fill="#fffefe",
)
)
d.add(
d.rect(
size=(width - 2 * padding, height - 2 * padding),
insert=(padding, padding),
fill="#eee" if debug else "#fff",
)
)
dp = Group(transform="translate(" + str(padding) + ", " + str(padding) + ")")
dp.add(d.text(header_text, insert=(0, 13), class_="header"))
+ dp.add(d.text(subheader_text, insert=(0, 31), class_="subheader"))
- dp.add(d.text(subheader_text, insert=(0, 33), class_="subheader"))
return d, dp
|
backend.src.processing.user.commit/get_commits_languages
|
Modified
|
avgupta456~github-trends
|
349b150ddf1c61ee42b5217c93abf38f4b935e53
|
simplify lang breakdown
|
<8>:<del> and "changedFiles" in commit
<13>:<del> num_langs = min(len(languages), commit["changedFiles"])
<14>:<del> total_repo_size = sum(
<15>:<add> total_repo_size = sum([language["size"] for language in languages])
<del> [language["size"] for language in languages[:num_langs]]
<16>:<del> )
<17>:<add> for language in languages:
<del> for language in languages[:num_langs]:
<20>:<add> lang_size = language["size"]
<del> additions = round(
<21>:<add> additions = round(commit["additions"] * lang_size / total_repo_size)
<del> commit["additions"] * language["size"] / total_repo_size
<22>:<del> )
<23>:<del> deletions = round(
<24>:<add> deletions = round(commit["deletions"] * lang_size / total_repo_size)
<del> commit["deletions"] * language["size"] / total_repo_size
<25>:<del> )
|
# module: backend.src.processing.user.commit
def get_commits_languages(
access_token: str,
node_ids: List[str],
commit_repos: List[str],
repo_infos: Dict[str, Any],
cutoff: int = CUTOFF,
):
<0> all_data = _get_commits_languages(access_token, node_ids, per_page=NODE_CHUNK_SIZE)
<1>
<2> out: List[Dict[str, Dict[str, int]]] = []
<3> for commit, commit_repo in zip(all_data, commit_repos):
<4> out.append({})
<5> if (
<6> "additions" in commit
<7> and "deletions" in commit
<8> and "changedFiles" in commit
<9> and commit["additions"] + commit["deletions"] < cutoff
<10> ):
<11> repo_info = repo_infos[commit_repo]["languages"]["edges"]
<12> languages = [x for x in repo_info if x["node"]["name"] not in BLACKLIST]
<13> num_langs = min(len(languages), commit["changedFiles"])
<14> total_repo_size = sum(
<15> [language["size"] for language in languages[:num_langs]]
<16> )
<17> for language in languages[:num_langs]:
<18> lang_name = language["node"]["name"]
<19> lang_color = language["node"]["color"]
<20> additions = round(
<21> commit["additions"] * language["size"] / total_repo_size
<22> )
<23> deletions = round(
<24> commit["deletions"] * language["size"] / total_repo_size
<25> )
<26> if additions > 0 or deletions > 0:
<27> out[-1][lang_name] = {
<28> "additions": additions,
<29> "deletions": deletions,
<30> "color": lang_color,
<31> }
<32>
<33> return out
<34>
|
===========unchanged ref 0===========
at: backend.src.processing.user.commit
_get_commits_languages(access_token: str, node_ids: List[str], per_page: int=NODE_CHUNK_SIZE) -> List[Dict[str, Any]]
at: src.constants
NODE_CHUNK_SIZE = 40 # number of nodes (commits) to query (max 100)
CUTOFF = 500 # if > cutoff lines, assume imported, don't count
BLACKLIST = ["Jupyter Notebook", "HTML"] # languages to ignore
at: typing
List = _alias(list, 1, inst=False, name='List')
Dict = _alias(dict, 2, inst=False, name='Dict')
|
backend.src.svg.template/get_bar_section
|
Modified
|
avgupta456~github-trends
|
01d4d9f8e7389b9c866ab1b130131668917e246d
|
languages use compact
|
<12>:<add> color = color or DEFAULT_COLOR
<del> color = color or "#ededed"
|
# module: backend.src.svg.template
def get_bar_section(
d: Drawing,
dataset: List[Tuple[str, str, List[Tuple[float, str]]]],
padding: int = 45,
bar_width: int = 210,
) -> Group:
<0> section = Group(transform="translate(0, " + str(padding) + ")")
<1> for i, (top_text, right_text, data_row) in enumerate(dataset):
<2> translate = "translate(0, " + str(40 * i) + ")"
<3> row = Group(transform=translate)
<4> row.add(d.text(top_text, insert=(2, 15), class_="lang-name"))
<5> row.add(d.text(right_text, insert=(bar_width + 10, 33), class_="lang-name"))
<6> progress = Drawing(width=str(bar_width), x="0", y="25")
<7> progress.add(
<8> d.rect(size=(bar_width, 8), insert=(0, 0), rx=5, ry=5, fill="#ddd")
<9> )
<10> total_percent, total_items = 0, len(data_row)
<11> for j, (percent, color) in enumerate(data_row):
<12> color = color or "#ededed"
<13> bar_percent = bar_width * percent / 100
<14> bar_total = bar_width * total_percent / 100
<15> box_size, insert = (bar_percent, 8), (bar_total, 0)
<16> progress.add(d.rect(size=box_size, insert=insert, rx=5, ry=5, fill=color))
<17>
<18> if total_items > 1:
<19> box_left, box_right = j > 0, j < total_items - 1
<20> box_size, insert = bar_percent - 10, bar_total + 5
<21> if box_left:
<22> box_size += 5
<23> insert -= 5
<24> if box_right:
<25> box_size += 5
<26> box</s>
|
===========below chunk 0===========
# module: backend.src.svg.template
def get_bar_section(
d: Drawing,
dataset: List[Tuple[str, str, List[Tuple[float, str]]]],
padding: int = 45,
bar_width: int = 210,
) -> Group:
# offset: 1
progress.add(d.rect(size=box_size, insert=insert, fill=color))
total_percent += percent
row.add(progress)
section.add(row)
return section
===========unchanged ref 0===========
at: backend.src.svg.template.get_template
d = Drawing(size=(width, height))
dp = Group(transform="translate(" + str(padding) + ", " + str(padding) + ")")
at: typing
Tuple = _TupleType(tuple, -1, inst=False, name='Tuple')
List = _alias(list, 1, inst=False, name='List')
|
backend.src.routers.users.svg/get_user_lang_svg
|
Modified
|
avgupta456~github-trends
|
01d4d9f8e7389b9c866ab1b130131668917e246d
|
languages use compact
|
<6>:<add> processed, time_str, use_percent, loc_metric, commits_excluded, compact
<del> processed, time_str, use_percent, loc_metric, commits_excluded
|
<s> def get_user_lang_svg(
response: Response,
user_id: str,
start_date: date = date.today() - timedelta(365),
end_date: date = date.today(),
time_range: str = "one_year",
timezone_str: str = "US/Eastern",
use_percent: bool = False,
include_private: bool = False,
loc_metric: str = "added",
+ compact: bool = False,
) -> Any:
<0> start_date, end_date, time_str = use_time_range(time_range, start_date, end_date)
<1> output = await get_user(user_id, start_date, end_date)
<2> if output is None:
<3> return get_loading_svg()
<4> processed, commits_excluded = get_top_languages(output, loc_metric, include_private)
<5> out = get_top_langs_svg(
<6> processed, time_str, use_percent, loc_metric, commits_excluded
<7> )
<8> return out
<9>
|
===========unchanged ref 0===========
at: backend.src.routers.users.svg
router = APIRouter()
at: datetime
timedelta(days: float=..., seconds: float=..., microseconds: float=..., milliseconds: float=..., minutes: float=..., hours: float=..., weeks: float=..., *, fold: int=...)
date()
at: datetime.date
__slots__ = '_year', '_month', '_day', '_hashcode'
today() -> _S
__str__ = isoformat
__radd__ = __add__
at: src.analytics.user.commits
get_top_languages(data: UserPackage, loc_metric: str, include_private: bool) -> Tuple[List[LanguageStats], int]
at: src.routers.users.get_data
get_user(user_id: str, start_date: date, end_date: date) -> Optional[UserPackage]
at: src.svg.error
get_loading_svg() -> Drawing
at: src.svg.top_langs
get_top_langs_svg(data: List[LanguageStats], time_str: str, use_percent: bool, loc_metric: str, commits_excluded: int, compact: bool) -> Drawing
at: src.utils
svg_fail_gracefully(func: Callable[..., Any])
use_time_range(time_range: str, start_date: date, end_date: date) -> Tuple[date, date, str]
===========changed ref 0===========
# module: backend.src.svg.template
+ DEFAULT_COLOR = "#858585"
===========changed ref 1===========
# module: backend.src.svg.template
+ def get_lang_name_section(d: Drawing, data: List[RepoLanguage]) -> Group:
+ section = Group(transform="translate(0, 80)")
+ for i, x in enumerate(data):
+ x_translate = str(130 * (i % 2))
+ y_translate = str(25 * (i // 2))
+ lang = Group(transform="translate(" + x_translate + ", " + y_translate + ")")
+ lang.add(Circle(center=(5, 5), r=5, fill=(data[i].color or DEFAULT_COLOR)))
+ lang.add(
+ d.text(
+ data[i].lang + " " + str(data[i].percent) + "%",
+ insert=(14, 9),
+ class_="lang-name",
+ )
+ )
+ section.add(lang)
+ return section
+
===========changed ref 2===========
# module: backend.src.svg.template
def get_bar_section(
d: Drawing,
dataset: List[Tuple[str, str, List[Tuple[float, str]]]],
padding: int = 45,
bar_width: int = 210,
) -> Group:
section = Group(transform="translate(0, " + str(padding) + ")")
for i, (top_text, right_text, data_row) in enumerate(dataset):
translate = "translate(0, " + str(40 * i) + ")"
row = Group(transform=translate)
row.add(d.text(top_text, insert=(2, 15), class_="lang-name"))
row.add(d.text(right_text, insert=(bar_width + 10, 33), class_="lang-name"))
progress = Drawing(width=str(bar_width), x="0", y="25")
progress.add(
d.rect(size=(bar_width, 8), insert=(0, 0), rx=5, ry=5, fill="#ddd")
)
total_percent, total_items = 0, len(data_row)
for j, (percent, color) in enumerate(data_row):
+ color = color or DEFAULT_COLOR
- color = color or "#ededed"
bar_percent = bar_width * percent / 100
bar_total = bar_width * total_percent / 100
box_size, insert = (bar_percent, 8), (bar_total, 0)
progress.add(d.rect(size=box_size, insert=insert, rx=5, ry=5, fill=color))
if total_items > 1:
box_left, box_right = j > 0, j < total_items - 1
box_size, insert = bar_percent - 10, bar_total + 5
if box_left:
box_size += 5
insert -= 5
if box_right:
box_size += 5
box_size, insert = (max(box_size, 3), 8),</s>
===========changed ref 3===========
# module: backend.src.svg.template
def get_bar_section(
d: Drawing,
dataset: List[Tuple[str, str, List[Tuple[float, str]]]],
padding: int = 45,
bar_width: int = 210,
) -> Group:
# offset: 1
<s> box_right:
box_size += 5
box_size, insert = (max(box_size, 3), 8), (insert, 0)
progress.add(d.rect(size=box_size, insert=insert, fill=color))
total_percent += percent
row.add(progress)
section.add(row)
return section
|
backend.src.svg.top_langs/get_top_langs_svg
|
Modified
|
avgupta456~github-trends
|
01d4d9f8e7389b9c866ab1b130131668917e246d
|
languages use compact
|
<8>:<add> height=185 if compact else 285,
<del> height=285,
<16>:<add> padding, width = 0, 0
<add> if compact:
<add> data_row = []
<add> for x in data[1:6]:
<del> for x in data[1:6]:
<17>:<add> data_row.append((x.percent, x.color))
<add> dataset.append(("", "", data_row))
<add> padding, width = 30, 260
<add> else:
<add> for x in data[1:6]:
<add> if use_percent:
<del> if use_percent:
<18>:<add> dataset.append((x.lang, str(x.percent) + "%", [(x.percent, x.color)]))
<del> dataset.append((x.lang, str(x.percent) + "%", [(x.percent, x.color)]))
<19>:<add> else:
<del> else:
<20>:<add> percent = 100 * x.loc / data[1].loc
<del> percent = 100 * x.loc / data[1].loc
<21>:<add> dataset.append((x.lang, format_number(x.loc), [(percent, x.color)]))
<del> dataset.append((x.lang, format_number(x.loc), [(percent, x.color)]))
<22>:<add> padding, width = 45, 210 if use_percent else 195
<23>:<del> section = get_bar_section(
<24>:<del> d=d, dataset=dataset, padding=45, bar_width=210 if use_percent else 195
<25>:<del> )
<26>:<add> dp.add(get
|
# module: backend.src.svg.top_langs
def get_top_langs_svg(
data: List[LanguageStats],
time_str: str,
use_percent: bool,
loc_metric: str,
commits_excluded: int,
+ compact: bool,
) -> Drawing:
<0> subheader = time_str
<1> if not use_percent:
<2> subheader += " | " + ("LOC Changed" if loc_metric == "changed" else "LOC Added")
<3> if commits_excluded > 50:
<4> subheader += " | " + str(commits_excluded) + " commits excluded"
<5>
<6> d, dp = get_template(
<7> width=300,
<8> height=285,
<9> padding=20,
<10> header_text="Most Used Languages",
<11> subheader_text=subheader,
<12> debug=False,
<13> )
<14>
<15> dataset: List[Tuple[str, str, List[Tuple[float, str]]]] = []
<16> for x in data[1:6]:
<17> if use_percent:
<18> dataset.append((x.lang, str(x.percent) + "%", [(x.percent, x.color)]))
<19> else:
<20> percent = 100 * x.loc / data[1].loc
<21> dataset.append((x.lang, format_number(x.loc), [(percent, x.color)]))
<22>
<23> section = get_bar_section(
<24> d=d, dataset=dataset, padding=45, bar_width=210 if use_percent else 195
<25> )
<26>
<27> dp.add(section)
<28> d.add(dp)
<29> return d
<30>
|
===========unchanged ref 0===========
at: src.models.user.analytics.LanguageStats
lang: str
loc: int
percent: float
color: Optional[str]
at: src.svg.template
format_number(num: int) -> str
get_template(width: int, height: int, padding: int, header_text: str, subheader_text: str, debug: bool=False) -> Tuple[Drawing, Group]
get_bar_section(d: Drawing, dataset: List[Tuple[str, str, List[Tuple[float, str]]]], padding: int=45, bar_width: int=210) -> Group
at: typing
Tuple = _TupleType(tuple, -1, inst=False, name='Tuple')
List = _alias(list, 1, inst=False, name='List')
===========changed ref 0===========
# module: backend.src.svg.template
+ DEFAULT_COLOR = "#858585"
===========changed ref 1===========
<s> def get_user_lang_svg(
response: Response,
user_id: str,
start_date: date = date.today() - timedelta(365),
end_date: date = date.today(),
time_range: str = "one_year",
timezone_str: str = "US/Eastern",
use_percent: bool = False,
include_private: bool = False,
loc_metric: str = "added",
+ compact: bool = False,
) -> Any:
start_date, end_date, time_str = use_time_range(time_range, start_date, end_date)
output = await get_user(user_id, start_date, end_date)
if output is None:
return get_loading_svg()
processed, commits_excluded = get_top_languages(output, loc_metric, include_private)
out = get_top_langs_svg(
+ processed, time_str, use_percent, loc_metric, commits_excluded, compact
- processed, time_str, use_percent, loc_metric, commits_excluded
)
return out
===========changed ref 2===========
# module: backend.src.svg.template
+ def get_lang_name_section(d: Drawing, data: List[RepoLanguage]) -> Group:
+ section = Group(transform="translate(0, 80)")
+ for i, x in enumerate(data):
+ x_translate = str(130 * (i % 2))
+ y_translate = str(25 * (i // 2))
+ lang = Group(transform="translate(" + x_translate + ", " + y_translate + ")")
+ lang.add(Circle(center=(5, 5), r=5, fill=(data[i].color or DEFAULT_COLOR)))
+ lang.add(
+ d.text(
+ data[i].lang + " " + str(data[i].percent) + "%",
+ insert=(14, 9),
+ class_="lang-name",
+ )
+ )
+ section.add(lang)
+ return section
+
===========changed ref 3===========
# module: backend.src.svg.template
def get_bar_section(
d: Drawing,
dataset: List[Tuple[str, str, List[Tuple[float, str]]]],
padding: int = 45,
bar_width: int = 210,
) -> Group:
section = Group(transform="translate(0, " + str(padding) + ")")
for i, (top_text, right_text, data_row) in enumerate(dataset):
translate = "translate(0, " + str(40 * i) + ")"
row = Group(transform=translate)
row.add(d.text(top_text, insert=(2, 15), class_="lang-name"))
row.add(d.text(right_text, insert=(bar_width + 10, 33), class_="lang-name"))
progress = Drawing(width=str(bar_width), x="0", y="25")
progress.add(
d.rect(size=(bar_width, 8), insert=(0, 0), rx=5, ry=5, fill="#ddd")
)
total_percent, total_items = 0, len(data_row)
for j, (percent, color) in enumerate(data_row):
+ color = color or DEFAULT_COLOR
- color = color or "#ededed"
bar_percent = bar_width * percent / 100
bar_total = bar_width * total_percent / 100
box_size, insert = (bar_percent, 8), (bar_total, 0)
progress.add(d.rect(size=box_size, insert=insert, rx=5, ry=5, fill=color))
if total_items > 1:
box_left, box_right = j > 0, j < total_items - 1
box_size, insert = bar_percent - 10, bar_total + 5
if box_left:
box_size += 5
insert -= 5
if box_right:
box_size += 5
box_size, insert = (max(box_size, 3), 8),</s>
===========changed ref 4===========
# module: backend.src.svg.template
def get_bar_section(
d: Drawing,
dataset: List[Tuple[str, str, List[Tuple[float, str]]]],
padding: int = 45,
bar_width: int = 210,
) -> Group:
# offset: 1
<s> box_right:
box_size += 5
box_size, insert = (max(box_size, 3), 8), (insert, 0)
progress.add(d.rect(size=box_size, insert=insert, fill=color))
total_percent += percent
row.add(progress)
section.add(row)
return section
|
backend.src.svg.top_repos/get_top_repos_svg
|
Modified
|
avgupta456~github-trends
|
e9fa5c8e1440f5e85662ef1d33976de13ad34862
|
language names for repo card
|
<16>:<add> for x in data[:4]:
<del> for x in data[:5]:
<18>:<add> for lang in x.langs:
<del> for j, lang in enumerate(x.langs):
<23>:<add> dp.add(get_bar_section(d=d, dataset=dataset, padding=45, bar_width=195))
<del> section = get_bar_section(d=d, dataset=dataset, padding=45, bar_width=195)
<25>:<add> langs = {}
<add> for x in data[:4]:
<add> for lang in x.langs:
<add> langs[lang.lang] = lang.color
<add> langs = list(langs.items())[:6]
<add>
<add> columns = {1: 1, 2: 2, 3: 3, 4: 2, 5: 3, 6: 3}[len(langs)]
<add> padding = 215 + (10 if columns == len(langs) else 0)
<add> dp.add(get_lang_name_section(d=d, data=langs, columns=columns, padding=padding))
<add>
<del> dp.add(section)
|
# module: backend.src.svg.top_repos
def get_top_repos_svg(
data: List[RepoStats], time_str: str, loc_metric: str, commits_excluded: int
) -> Drawing:
<0> subheader = time_str
<1> subheader += " | " + ("LOC Changed" if loc_metric == "changed" else "LOC Added")
<2> if commits_excluded > 50:
<3> subheader += " | " + str(commits_excluded) + " commits excluded"
<4>
<5> d, dp = get_template(
<6> width=300,
<7> height=285,
<8> padding=20,
<9> header_text="Most Contributed Repositories",
<10> subheader_text=subheader,
<11> debug=False,
<12> )
<13>
<14> dataset: List[Tuple[str, str, List[Tuple[float, str]]]] = []
<15> total = data[0].loc
<16> for x in data[:5]:
<17> data_row = []
<18> for j, lang in enumerate(x.langs):
<19> data_row.append((100 * lang.loc / total, lang.color))
<20> name = "private/repository" if x.private else x.repo
<21> dataset.append((name, format_number(x.loc), data_row))
<22>
<23> section = get_bar_section(d=d, dataset=dataset, padding=45, bar_width=195)
<24>
<25> dp.add(section)
<26> d.add(dp)
<27> return d
<28>
|
===========unchanged ref 0===========
at: src.models.user.analytics.RepoLanguage
lang: str
color: str
loc: int
at: src.models.user.analytics.RepoStats
repo: str
private: bool
langs: List[RepoLanguage]
loc: int
at: src.svg.template
format_number(num: int) -> str
get_template(width: int, height: int, padding: int, header_text: str, subheader_text: str, debug: bool=False) -> Tuple[Drawing, Group]
get_bar_section(d: Drawing, dataset: List[Tuple[str, str, List[Tuple[float, str]]]], padding: int=45, bar_width: int=210) -> Group
at: typing
Tuple = _TupleType(tuple, -1, inst=False, name='Tuple')
List = _alias(list, 1, inst=False, name='List')
|
backend.src.svg.template/get_lang_name_section
|
Modified
|
avgupta456~github-trends
|
e9fa5c8e1440f5e85662ef1d33976de13ad34862
|
language names for repo card
|
<0>:<add> section = Group(transform="translate(0, " + str(padding) + ")")
<del> section = Group(transform="translate(0, 80)")
<2>:<add> x_translate = str((260 / columns) * (i % columns))
<del> x_translate = str(130 * (i % 2))
<3>:<add> y_translate = str(20 * (i // columns))
<del> y_translate = str(25 * (i // 2))
<5>:<add> lang.add(Circle(center=(5, 5), r=5, fill=(data[i][1] or DEFAULT_COLOR)))
<del> lang.add(Circle(center=(5, 5), r=5, fill=(data[i].color or DEFAULT_COLOR)))
<6>:<del> lang.add(
<7>:<del> d.text(
<8>:<del> data[i].lang + " " + str(data[i].percent) + "%",
<9>:<del> insert=(14, 9),
<10>:<del> class_="lang-name",
<11>:<del> )
<12>:<del> )
<13>:<add> lang.add(d.text(data[i][0], insert=(14, 9), class_="lang-name"))
|
# module: backend.src.svg.template
+ def get_lang_name_section(
+ d: Drawing, data: List[Tuple[str, str]], columns: int = 2, padding: int = 80
+ ) -> Group:
- def get_lang_name_section(d: Drawing, data: List[RepoLanguage]) -> Group:
<0> section = Group(transform="translate(0, 80)")
<1> for i, x in enumerate(data):
<2> x_translate = str(130 * (i % 2))
<3> y_translate = str(25 * (i // 2))
<4> lang = Group(transform="translate(" + x_translate + ", " + y_translate + ")")
<5> lang.add(Circle(center=(5, 5), r=5, fill=(data[i].color or DEFAULT_COLOR)))
<6> lang.add(
<7> d.text(
<8> data[i].lang + " " + str(data[i].percent) + "%",
<9> insert=(14, 9),
<10> class_="lang-name",
<11> )
<12> )
<13> section.add(lang)
<14> return section
<15>
|
===========unchanged ref 0===========
at: backend.src.svg.template
DEFAULT_COLOR = "#858585"
===========changed ref 0===========
# module: backend.src.svg.top_repos
def get_top_repos_svg(
data: List[RepoStats], time_str: str, loc_metric: str, commits_excluded: int
) -> Drawing:
subheader = time_str
subheader += " | " + ("LOC Changed" if loc_metric == "changed" else "LOC Added")
if commits_excluded > 50:
subheader += " | " + str(commits_excluded) + " commits excluded"
d, dp = get_template(
width=300,
height=285,
padding=20,
header_text="Most Contributed Repositories",
subheader_text=subheader,
debug=False,
)
dataset: List[Tuple[str, str, List[Tuple[float, str]]]] = []
total = data[0].loc
+ for x in data[:4]:
- for x in data[:5]:
data_row = []
+ for lang in x.langs:
- for j, lang in enumerate(x.langs):
data_row.append((100 * lang.loc / total, lang.color))
name = "private/repository" if x.private else x.repo
dataset.append((name, format_number(x.loc), data_row))
+ dp.add(get_bar_section(d=d, dataset=dataset, padding=45, bar_width=195))
- section = get_bar_section(d=d, dataset=dataset, padding=45, bar_width=195)
+ langs = {}
+ for x in data[:4]:
+ for lang in x.langs:
+ langs[lang.lang] = lang.color
+ langs = list(langs.items())[:6]
+
+ columns = {1: 1, 2: 2, 3: 3, 4: 2, 5: 3, 6: 3}[len(langs)]
+ padding = 215 + (10 if columns == len(langs) else 0)
+ dp.add(get_lang_name_section(d</s>
===========changed ref 1===========
# module: backend.src.svg.top_repos
def get_top_repos_svg(
data: List[RepoStats], time_str: str, loc_metric: str, commits_excluded: int
) -> Drawing:
# offset: 1
<s> + (10 if columns == len(langs) else 0)
+ dp.add(get_lang_name_section(d=d, data=langs, columns=columns, padding=padding))
+
- dp.add(section)
d.add(dp)
return d
|
backend.src.svg.top_langs/get_top_langs_svg
|
Modified
|
avgupta456~github-trends
|
e9fa5c8e1440f5e85662ef1d33976de13ad34862
|
language names for repo card
|
<8>:<add> height=175 if compact else 285,
<del> height=185 if compact else 285,
<34>:<add> langs = [(x.lang + " " + str(x.percent) + "%", x.color) for x in data[1:6]]
<35>:<add> dp.add(get_lang_name_section(d=d, data=langs))
<del> dp.add(get_lang_name_section(d=d
|
# module: backend.src.svg.top_langs
def get_top_langs_svg(
data: List[LanguageStats],
time_str: str,
use_percent: bool,
loc_metric: str,
commits_excluded: int,
compact: bool,
) -> Drawing:
<0> subheader = time_str
<1> if not use_percent:
<2> subheader += " | " + ("LOC Changed" if loc_metric == "changed" else "LOC Added")
<3> if commits_excluded > 50:
<4> subheader += " | " + str(commits_excluded) + " commits excluded"
<5>
<6> d, dp = get_template(
<7> width=300,
<8> height=185 if compact else 285,
<9> padding=20,
<10> header_text="Most Used Languages",
<11> subheader_text=subheader,
<12> debug=False,
<13> )
<14>
<15> dataset: List[Tuple[str, str, List[Tuple[float, str]]]] = []
<16> padding, width = 0, 0
<17> if compact:
<18> data_row = []
<19> for x in data[1:6]:
<20> data_row.append((x.percent, x.color))
<21> dataset.append(("", "", data_row))
<22> padding, width = 30, 260
<23> else:
<24> for x in data[1:6]:
<25> if use_percent:
<26> dataset.append((x.lang, str(x.percent) + "%", [(x.percent, x.color)]))
<27> else:
<28> percent = 100 * x.loc / data[1].loc
<29> dataset.append((x.lang, format_number(x.loc), [(percent, x.color)]))
<30> padding, width = 45, 210 if use_percent else 195
<31>
<32> dp.add(get_bar_section(d=d, dataset=dataset, padding=padding, bar_width=width))
<33>
<34> if compact:
<35> dp.add(get_lang_name_section(d=d</s>
|
===========below chunk 0===========
# module: backend.src.svg.top_langs
def get_top_langs_svg(
data: List[LanguageStats],
time_str: str,
use_percent: bool,
loc_metric: str,
commits_excluded: int,
compact: bool,
) -> Drawing:
# offset: 1
d.add(dp)
return d
===========unchanged ref 0===========
at: src.models.user.analytics.LanguageStats
lang: str
loc: int
percent: float
color: Optional[str]
at: src.svg.template
format_number(num: int) -> str
get_template(width: int, height: int, padding: int, header_text: str, subheader_text: str, debug: bool=False) -> Tuple[Drawing, Group]
get_bar_section(d: Drawing, dataset: List[Tuple[str, str, List[Tuple[float, str]]]], padding: int=45, bar_width: int=210) -> Group
get_lang_name_section(d: Drawing, data: List[RepoLanguage]) -> Group
at: typing
Tuple = _TupleType(tuple, -1, inst=False, name='Tuple')
List = _alias(list, 1, inst=False, name='List')
===========changed ref 0===========
# module: backend.src.svg.template
+ def get_lang_name_section(
+ d: Drawing, data: List[Tuple[str, str]], columns: int = 2, padding: int = 80
+ ) -> Group:
- def get_lang_name_section(d: Drawing, data: List[RepoLanguage]) -> Group:
+ section = Group(transform="translate(0, " + str(padding) + ")")
- section = Group(transform="translate(0, 80)")
for i, x in enumerate(data):
+ x_translate = str((260 / columns) * (i % columns))
- x_translate = str(130 * (i % 2))
+ y_translate = str(20 * (i // columns))
- y_translate = str(25 * (i // 2))
lang = Group(transform="translate(" + x_translate + ", " + y_translate + ")")
+ lang.add(Circle(center=(5, 5), r=5, fill=(data[i][1] or DEFAULT_COLOR)))
- lang.add(Circle(center=(5, 5), r=5, fill=(data[i].color or DEFAULT_COLOR)))
- lang.add(
- d.text(
- data[i].lang + " " + str(data[i].percent) + "%",
- insert=(14, 9),
- class_="lang-name",
- )
- )
+ lang.add(d.text(data[i][0], insert=(14, 9), class_="lang-name"))
section.add(lang)
return section
===========changed ref 1===========
# module: backend.src.svg.top_repos
def get_top_repos_svg(
data: List[RepoStats], time_str: str, loc_metric: str, commits_excluded: int
) -> Drawing:
subheader = time_str
subheader += " | " + ("LOC Changed" if loc_metric == "changed" else "LOC Added")
if commits_excluded > 50:
subheader += " | " + str(commits_excluded) + " commits excluded"
d, dp = get_template(
width=300,
height=285,
padding=20,
header_text="Most Contributed Repositories",
subheader_text=subheader,
debug=False,
)
dataset: List[Tuple[str, str, List[Tuple[float, str]]]] = []
total = data[0].loc
+ for x in data[:4]:
- for x in data[:5]:
data_row = []
+ for lang in x.langs:
- for j, lang in enumerate(x.langs):
data_row.append((100 * lang.loc / total, lang.color))
name = "private/repository" if x.private else x.repo
dataset.append((name, format_number(x.loc), data_row))
+ dp.add(get_bar_section(d=d, dataset=dataset, padding=45, bar_width=195))
- section = get_bar_section(d=d, dataset=dataset, padding=45, bar_width=195)
+ langs = {}
+ for x in data[:4]:
+ for lang in x.langs:
+ langs[lang.lang] = lang.color
+ langs = list(langs.items())[:6]
+
+ columns = {1: 1, 2: 2, 3: 3, 4: 2, 5: 3, 6: 3}[len(langs)]
+ padding = 215 + (10 if columns == len(langs) else 0)
+ dp.add(get_lang_name_section(d</s>
===========changed ref 2===========
# module: backend.src.svg.top_repos
def get_top_repos_svg(
data: List[RepoStats], time_str: str, loc_metric: str, commits_excluded: int
) -> Drawing:
# offset: 1
<s> + (10 if columns == len(langs) else 0)
+ dp.add(get_lang_name_section(d=d, data=langs, columns=columns, padding=padding))
+
- dp.add(section)
d.add(dp)
return d
|
backend.src.routers.users.get_data/get_user
|
Modified
|
avgupta456~github-trends
|
a52876b9808acbb5322e301e48fca099b82a6879
|
cache get_user()
|
<3>:<add> return (False, None) # type: ignore
<del> return None
<9>:<add> return (True, output) # type: ignore
<del> return output
|
# module: backend.src.routers.users.get_data
+ @alru_cache(max_size=128)
+ async def get_user(
- def get_user(
user_id: str, start_date: date, end_date: date
) -> Optional[UserPackage]:
<0> output = await _get_user(user_id)
<1>
<2> if output is None:
<3> return None
<4>
<5> output = trim_package(output, start_date, end_date)
<6>
<7> # TODO: handle timezone_str here
<8>
<9> return output
<10>
|
===========unchanged ref 0===========
at: backend.src.routers.users.get_data
_get_user(user_id: str) -> Optional[UserPackage]
at: datetime
date()
at: src.analytics.user.utils
trim_package(data: UserPackage, start_date: date, end_date: date) -> UserPackage
at: src.helper.alru_cache
alru_cache(max_size: int=128, ttl: timedelta=timedelta(hours=1))
|
backend.src.db.functions.get/get_user_by_user_id
|
Modified
|
avgupta456~github-trends
|
6b8a3fccdae14d4661543705ad4f396f3352f875
|
misc fixes
|
<16>:<add> except (TypeError, KeyError, ValidationError):
<del> except (KeyError, ValidationError):
|
# module: backend.src.db.functions.get
@alru_cache(max_size=128)
+ async def get_user_by_user_id(
+ user_id: str, use_cache: bool = True
+ ) -> Optional[UserModel]:
- async def get_user_by_user_id(user_id: str) -> Optional[UserModel]:
<0> user: Optional[Dict[str, Any]] = await USERS.find_one({"user_id": user_id}) # type: ignore
<1>
<2> # (flag, value) output through decorator returns value
<3>
<4> if user is None:
<5> # flag is false, don't cache
<6> return (False, None) # type: ignore
<7>
<8> if "raw_data" not in user:
<9> # flag is false, don't cache
<10> return (False, UserModel.parse_obj(user)) # type: ignore
<11>
<12> try:
<13> raw_data = decompress(user["raw_data"])
<14> # flag is true, do cache
<15> return (True, UserModel.parse_obj({**user, "raw_data": raw_data})) # type: ignore
<16> except (KeyError, ValidationError):
<17> return (False, UserModel.parse_obj({**user, "raw_data": None})) # type: ignore
<18>
|
===========unchanged ref 0===========
at: src.db.functions.compression
decompress(data: Dict[str, Any]) -> Dict[str, Any]
at: src.db.mongodb
USERS = DB.users # type: ignore
at: src.helper.alru_cache
alru_cache(max_size: int=128, ttl: timedelta=timedelta(hours=1))
at: typing
Dict = _alias(dict, 2, inst=False, name='Dict')
|
backend.src.db.functions.get/get_user_by_access_token
|
Modified
|
avgupta456~github-trends
|
6b8a3fccdae14d4661543705ad4f396f3352f875
|
misc fixes
|
<18>:<add> except (TypeError, KeyError, ValidationError):
<del> except (KeyError, ValidationError):
|
# module: backend.src.db.functions.get
@alru_cache(max_size=128)
+ async def get_user_by_access_token(
+ access_token: str, use_cache: bool = True
+ ) -> Optional[UserModel]:
- async def get_user_by_access_token(access_token: str) -> Optional[UserModel]:
<0> user: Optional[Dict[str, Any]] = await USERS.find_one( # type: ignore
<1> {"access_token": access_token}
<2> )
<3>
<4> # (flag, value) output through decorator returns value
<5>
<6> if user is None:
<7> # flag is false, don't cache
<8> return (False, None) # type: ignore
<9>
<10> if "raw_data" not in user:
<11> # flag is false, don't cache
<12> return (False, UserModel.parse_obj(user)) # type: ignore
<13>
<14> try:
<15> raw_data = decompress(user["raw_data"])
<16> # flag is true, do cache
<17> return (True, UserModel.parse_obj({**user, "raw_data": raw_data})) # type: ignore
<18> except (KeyError, ValidationError):
<19> return (False, UserModel.parse_obj({**user, "raw_data": None})) # type: ignore
<20>
|
===========unchanged ref 0===========
at: src.db.functions.compression
decompress(data: Dict[str, Any]) -> Dict[str, Any]
at: src.db.mongodb
USERS = DB.users # type: ignore
at: src.helper.alru_cache
alru_cache(max_size: int=128, ttl: timedelta=timedelta(hours=1))
at: typing
Dict = _alias(dict, 2, inst=False, name='Dict')
===========changed ref 0===========
# module: backend.src.db.functions.get
@alru_cache(max_size=128)
+ async def get_user_by_user_id(
+ user_id: str, use_cache: bool = True
+ ) -> Optional[UserModel]:
- async def get_user_by_user_id(user_id: str) -> Optional[UserModel]:
user: Optional[Dict[str, Any]] = await USERS.find_one({"user_id": user_id}) # type: ignore
# (flag, value) output through decorator returns value
if user is None:
# flag is false, don't cache
return (False, None) # type: ignore
if "raw_data" not in user:
# flag is false, don't cache
return (False, UserModel.parse_obj(user)) # type: ignore
try:
raw_data = decompress(user["raw_data"])
# flag is true, do cache
return (True, UserModel.parse_obj({**user, "raw_data": raw_data})) # type: ignore
+ except (TypeError, KeyError, ValidationError):
- except (KeyError, ValidationError):
return (False, UserModel.parse_obj({**user, "raw_data": None})) # type: ignore
|
backend.src.external.github_api.graphql.template/get_template
|
Modified
|
avgupta456~github-trends
|
6b8a3fccdae14d4661543705ad4f396f3352f875
|
misc fixes
|
<30>:<add> if r.status_code in [401, 403]:
<del> if r.status_code == 403:
|
# module: backend.src.external.github_api.graphql.template
def get_template(query: Dict[str, Any], access_token: str) -> Dict[str, Any]:
<0> """Template for interacting with the GitHub GraphQL API"""
<1> start = datetime.now()
<2> headers: Dict[str, str] = {"Authorization": "bearer " + access_token}
<3>
<4> try:
<5> r = s.post( # type: ignore
<6> "https://api.github.com/graphql",
<7> json=query,
<8> headers=headers,
<9> timeout=TIMEOUT,
<10> )
<11> except ReadTimeout:
<12> raise GraphQLErrorTimeout("GraphQL Error: Request Timeout")
<13>
<14> print("GraphQL", datetime.now() - start)
<15> if r.status_code == 200:
<16> data = r.json() # type: ignore
<17> if "errors" in data:
<18> if (
<19> "type" in data["errors"][0]
<20> and data["errors"][0]["type"] == "SERVICE_UNAVAILABLE"
<21> and "path" in data["errors"][0]
<22> and isinstance(data["errors"][0]["path"], list)
<23> and len(data["errors"][0]["path"]) == 3 # type: ignore
<24> and data["errors"][0]["path"][0] == "nodes"
<25> ):
<26> raise GraphQLErrorMissingNode(node=int(data["errors"][0]["path"][1])) # type: ignore
<27> raise GraphQLError("GraphQL Error: " + str(data["errors"]))
<28> return data
<29>
<30> if r.status_code == 403:
<31> raise GraphQLErrorAuth("GraphQL Error: Unauthorized")
<32>
<33> if r.status_code == 502:
<34> raise GraphQLErrorTimeout("GraphQL Error: Request Timeout")
<35>
<36> raise GraphQLError("GraphQL Error: " + str(r.status_code))
<37>
|
===========unchanged ref 0===========
at: backend.src.external.github_api.graphql.template
s = requests.session()
GraphQLError(*args: object)
GraphQLErrorMissingNode(node: int)
GraphQLErrorAuth(*args: object)
GraphQLErrorTimeout(*args: object)
at: datetime
datetime()
at: datetime.datetime
__slots__ = date.__slots__ + time.__slots__
now(tz: Optional[_tzinfo]=...) -> _S
__radd__ = __add__
at: requests.exceptions
ReadTimeout(*args, **kwargs)
at: requests.models.Response
__attrs__ = [
"_content",
"status_code",
"headers",
"url",
"history",
"encoding",
"reason",
"cookies",
"elapsed",
"request",
]
json(**kwargs) -> Any
at: requests.models.Response.__init__
self.status_code = None
at: requests.sessions.Session
__attrs__ = [
"headers",
"cookies",
"auth",
"proxies",
"hooks",
"params",
"verify",
"cert",
"adapters",
"stream",
"trust_env",
"max_redirects",
]
post(url: Union[Text, bytes], data: _Data=..., json: Optional[Any]=..., **kwargs) -> Response
at: src.constants
TIMEOUT = 15 # max seconds to wait for api response
at: typing
Dict = _alias(dict, 2, inst=False, name='Dict')
===========changed ref 0===========
# module: backend.src.db.functions.get
@alru_cache(max_size=128)
+ async def get_user_by_user_id(
+ user_id: str, use_cache: bool = True
+ ) -> Optional[UserModel]:
- async def get_user_by_user_id(user_id: str) -> Optional[UserModel]:
user: Optional[Dict[str, Any]] = await USERS.find_one({"user_id": user_id}) # type: ignore
# (flag, value) output through decorator returns value
if user is None:
# flag is false, don't cache
return (False, None) # type: ignore
if "raw_data" not in user:
# flag is false, don't cache
return (False, UserModel.parse_obj(user)) # type: ignore
try:
raw_data = decompress(user["raw_data"])
# flag is true, do cache
return (True, UserModel.parse_obj({**user, "raw_data": raw_data})) # type: ignore
+ except (TypeError, KeyError, ValidationError):
- except (KeyError, ValidationError):
return (False, UserModel.parse_obj({**user, "raw_data": None})) # type: ignore
===========changed ref 1===========
# module: backend.src.db.functions.get
@alru_cache(max_size=128)
+ async def get_user_by_access_token(
+ access_token: str, use_cache: bool = True
+ ) -> Optional[UserModel]:
- async def get_user_by_access_token(access_token: str) -> Optional[UserModel]:
user: Optional[Dict[str, Any]] = await USERS.find_one( # type: ignore
{"access_token": access_token}
)
# (flag, value) output through decorator returns value
if user is None:
# flag is false, don't cache
return (False, None) # type: ignore
if "raw_data" not in user:
# flag is false, don't cache
return (False, UserModel.parse_obj(user)) # type: ignore
try:
raw_data = decompress(user["raw_data"])
# flag is true, do cache
return (True, UserModel.parse_obj({**user, "raw_data": raw_data})) # type: ignore
+ except (TypeError, KeyError, ValidationError):
- except (KeyError, ValidationError):
return (False, UserModel.parse_obj({**user, "raw_data": None})) # type: ignore
|
backend.src.helper.alru_cache/alru_cache
|
Modified
|
avgupta456~github-trends
|
6b8a3fccdae14d4661543705ad4f396f3352f875
|
misc fixes
|
<6>:<add> if "use_cache" in kwargs and kwargs["use_cache"] is False:
<add> (flag, value) = await func(*args, **kwargs)
<add> return value
|
# module: backend.src.helper.alru_cache
# NOTE: return None to avoid caching
def alru_cache(max_size: int = 128, ttl: timedelta = timedelta(hours=1)):
<0> def decorator(func: Callable[..., Any]) -> Any:
<1> cache: Dict[Any, Tuple[datetime, Any]] = {}
<2> keys: List[Any] = []
<3>
<4> @wraps(func)
<5> async def wrapper(*args: List[Any], **kwargs: Dict[str, Any]) -> Any:
<6> now = datetime.now()
<7> key = tuple(args), frozenset(kwargs.items())
<8> if key not in cache or now - cache[key][0] > ttl:
<9> (flag, value) = await func(*args, **kwargs)
<10> if not flag:
<11> return value
<12> cache[key] = (now, value)
<13> keys.append(key)
<14> if len(keys) > max_size:
<15> del cache[keys.pop(0)]
<16> return cache[key][1]
<17>
<18> return wrapper
<19>
<20> return decorator
<21>
|
===========unchanged ref 0===========
at: datetime
timedelta(days: float=..., seconds: float=..., microseconds: float=..., milliseconds: float=..., minutes: float=..., hours: float=..., weeks: float=..., *, fold: int=...)
datetime()
at: datetime.datetime
__slots__ = date.__slots__ + time.__slots__
now(tz: Optional[_tzinfo]=...) -> _S
__radd__ = __add__
at: functools
wraps(wrapped: _AnyCallable, assigned: Sequence[str]=..., updated: Sequence[str]=...) -> Callable[[_T], _T]
at: typing
Callable = _CallableType(collections.abc.Callable, 2)
Tuple = _TupleType(tuple, -1, inst=False, name='Tuple')
List = _alias(list, 1, inst=False, name='List')
Dict = _alias(dict, 2, inst=False, name='Dict')
===========changed ref 0===========
# module: backend.src.db.functions.get
@alru_cache(max_size=128)
+ async def get_user_by_user_id(
+ user_id: str, use_cache: bool = True
+ ) -> Optional[UserModel]:
- async def get_user_by_user_id(user_id: str) -> Optional[UserModel]:
user: Optional[Dict[str, Any]] = await USERS.find_one({"user_id": user_id}) # type: ignore
# (flag, value) output through decorator returns value
if user is None:
# flag is false, don't cache
return (False, None) # type: ignore
if "raw_data" not in user:
# flag is false, don't cache
return (False, UserModel.parse_obj(user)) # type: ignore
try:
raw_data = decompress(user["raw_data"])
# flag is true, do cache
return (True, UserModel.parse_obj({**user, "raw_data": raw_data})) # type: ignore
+ except (TypeError, KeyError, ValidationError):
- except (KeyError, ValidationError):
return (False, UserModel.parse_obj({**user, "raw_data": None})) # type: ignore
===========changed ref 1===========
# module: backend.src.db.functions.get
@alru_cache(max_size=128)
+ async def get_user_by_access_token(
+ access_token: str, use_cache: bool = True
+ ) -> Optional[UserModel]:
- async def get_user_by_access_token(access_token: str) -> Optional[UserModel]:
user: Optional[Dict[str, Any]] = await USERS.find_one( # type: ignore
{"access_token": access_token}
)
# (flag, value) output through decorator returns value
if user is None:
# flag is false, don't cache
return (False, None) # type: ignore
if "raw_data" not in user:
# flag is false, don't cache
return (False, UserModel.parse_obj(user)) # type: ignore
try:
raw_data = decompress(user["raw_data"])
# flag is true, do cache
return (True, UserModel.parse_obj({**user, "raw_data": raw_data})) # type: ignore
+ except (TypeError, KeyError, ValidationError):
- except (KeyError, ValidationError):
return (False, UserModel.parse_obj({**user, "raw_data": None})) # type: ignore
===========changed ref 2===========
# module: backend.src.external.github_api.graphql.template
def get_template(query: Dict[str, Any], access_token: str) -> Dict[str, Any]:
"""Template for interacting with the GitHub GraphQL API"""
start = datetime.now()
headers: Dict[str, str] = {"Authorization": "bearer " + access_token}
try:
r = s.post( # type: ignore
"https://api.github.com/graphql",
json=query,
headers=headers,
timeout=TIMEOUT,
)
except ReadTimeout:
raise GraphQLErrorTimeout("GraphQL Error: Request Timeout")
print("GraphQL", datetime.now() - start)
if r.status_code == 200:
data = r.json() # type: ignore
if "errors" in data:
if (
"type" in data["errors"][0]
and data["errors"][0]["type"] == "SERVICE_UNAVAILABLE"
and "path" in data["errors"][0]
and isinstance(data["errors"][0]["path"], list)
and len(data["errors"][0]["path"]) == 3 # type: ignore
and data["errors"][0]["path"][0] == "nodes"
):
raise GraphQLErrorMissingNode(node=int(data["errors"][0]["path"][1])) # type: ignore
raise GraphQLError("GraphQL Error: " + str(data["errors"]))
return data
+ if r.status_code in [401, 403]:
- if r.status_code == 403:
raise GraphQLErrorAuth("GraphQL Error: Unauthorized")
if r.status_code == 502:
raise GraphQLErrorTimeout("GraphQL Error: Request Timeout")
raise GraphQLError("GraphQL Error: " + str(r.status_code))
|
backend.src.routers.users.dev/get_user_raw
|
Modified
|
avgupta456~github-trends
|
d0cf1b8621100f0623573b0f397d4028095ff4a4
|
support public and private auth
|
<0>:<add> new_access_token: str = access_token if access_token else ""
<add> if not access_token:
<add> db_user = await get_user_by_user_id(user_id, use_cache=False)
<del> db_user = await get_user_by_user_id(user_id)
<1>:<add> if db_user is None or db_user.access_token == "":
<del> if db_user is None or db_user.access_token == "":
<2>:<add> raise LookupError("Invalid UserId")
<del> raise LookupError("Invalid UserId")
<3>:<add> new_access_token = db_user.access_token
<5>:<add> print(start_date, end_date, user_id, new_access_token, timezone_str)
<del> data = await get_data(
<6>:<add> data = await get_data(user_id, new_access_token, start_date, end_date, timezone_str)
<del> user_id, db_user.access_token, start_date, end_date, timezone_str
<7>:<del> )
|
<s>_id}", status_code=status.HTTP_200_OK)
@async_fail_gracefully
async def get_user_raw(
response: Response,
user_id: str,
+ access_token: Optional[str] = None,
start_date: date = date.today() - timedelta(365),
end_date: date = date.today(),
time_range: str = "one_month",
timezone_str: str = "US/Eastern",
) -> UserPackage:
<0> db_user = await get_user_by_user_id(user_id)
<1> if db_user is None or db_user.access_token == "":
<2> raise LookupError("Invalid UserId")
<3>
<4> start_date, end_date, _ = use_time_range(time_range, start_date, end_date)
<5> data = await get_data(
<6> user_id, db_user.access_token, start_date, end_date, timezone_str
<7> )
<8>
<9> return data
<10>
|
===========unchanged ref 0===========
at: backend.src.routers.users.dev
router = APIRouter()
at: datetime
timedelta(days: float=..., seconds: float=..., microseconds: float=..., milliseconds: float=..., minutes: float=..., hours: float=..., weeks: float=..., *, fold: int=...)
date()
at: datetime.date
__slots__ = '_year', '_month', '_day', '_hashcode'
today() -> _S
__str__ = isoformat
__radd__ = __add__
at: src.db.functions.get
Callable(*args: List[Any], **kwargs: Dict[str, Any]) -> Any
at: src.utils
async_fail_gracefully(func: Callable[..., Any])
use_time_range(time_range: str, start_date: date, end_date: date) -> Tuple[date, date, str]
===========changed ref 0===========
# module: backend.src.constants
# GLOBAL
PROD = os.getenv("PROD", "False") == "True"
DOCKER = os.getenv("DOCKER", "False") == "True"
PROJECT_ID = "github-298920"
BACKEND_URL = "https://api.githubtrends.io" if PROD else "http://localhost:8000"
# API
TIMEOUT = 15 # max seconds to wait for api response
+ NODE_CHUNK_SIZE = 20 # number of nodes (commits) to query (max 100)
- NODE_CHUNK_SIZE = 40 # number of nodes (commits) to query (max 100)
+ NODE_THREADS = 20 # number of node queries simultaneously (avoid blacklisting)
- NODE_THREADS = 40 # number of node queries simultaneously (avoid blacklisting)
CUTOFF = 500 # if > cutoff lines, assume imported, don't count
# CUSTOMIZATION
BLACKLIST = ["Jupyter Notebook", "HTML"] # languages to ignore
# OAUTH
OAUTH_CLIENT_ID = os.getenv("OAUTH_CLIENT_ID", "") # client ID for GitHub OAuth App
OAUTH_CLIENT_SECRET = os.getenv("OAUTH_CLIENT_SECRET", "") # client secret for App
OAUTH_REDIRECT_URI = os.getenv("OAUTH_REDIRECT_URI", "") # redirect uri for App
# PUBSUB
PUBSUB_PUB = os.getenv("PUBSUB_PUB", "False") == "True"
PUBSUB_TOKEN = os.getenv("PUBSUB_TOKEN", "")
LOCAL_SUBSCRIBER = ( # based on name of Docker container
"http://" + ("subscriber" if DOCKER else "localhost") + ":8001/pubsub/sub/"
)
# MONGODB
MONGODB_PASSWORD = os.getenv("MONGODB_PASSWORD", "")
# SENTRY
SENTRY_DSN = os.getenv("SENTRY_DSN", "")
# TESTING
TEST_USER_ID = "AshishGupta938" # for testing, previously "avgupta456"</s>
===========changed ref 1===========
# module: backend.src.constants
# offset: 1
<s>
TEST_USER_ID = "AshishGupta938" # for testing, previously "avgupta456"
TEST_TOKEN = os.getenv("AUTH_TOKEN", "") # for authentication
|
backend.src.routers.users.dev/get_user_raw
|
Modified
|
avgupta456~github-trends
|
b9f8685611d399e39870f1e882e224694073f678
|
add query rate limit to dev endpoint
|
<7>:<add> start_query_limit = get_query_limit(access_token=new_access_token)
<10>:<add> end_query_limit = get_query_limit(access_token=new_access_token)
<add> print("query limit used", start_query_limit - end_query_limit)
<add> print("query limit remaining", end_query_limit)
|
<s>user_id}", status_code=status.HTTP_200_OK)
@async_fail_gracefully
async def get_user_raw(
response: Response,
user_id: str,
access_token: Optional[str] = None,
start_date: date = date.today() - timedelta(365),
end_date: date = date.today(),
time_range: str = "one_month",
timezone_str: str = "US/Eastern",
) -> UserPackage:
<0> new_access_token: str = access_token if access_token else ""
<1> if not access_token:
<2> db_user = await get_user_by_user_id(user_id, use_cache=False)
<3> if db_user is None or db_user.access_token == "":
<4> raise LookupError("Invalid UserId")
<5> new_access_token = db_user.access_token
<6>
<7> start_date, end_date, _ = use_time_range(time_range, start_date, end_date)
<8> print(start_date, end_date, user_id, new_access_token, timezone_str)
<9> data = await get_data(user_id, new_access_token, start_date, end_date, timezone_str)
<10>
<11> return data
<12>
|
===========unchanged ref 0===========
at: backend.src.routers.users.dev
router = APIRouter()
at: datetime
timedelta(days: float=..., seconds: float=..., microseconds: float=..., milliseconds: float=..., minutes: float=..., hours: float=..., weeks: float=..., *, fold: int=...)
date()
at: datetime.date
__slots__ = '_year', '_month', '_day', '_hashcode'
today() -> _S
__str__ = isoformat
__radd__ = __add__
at: src.db.functions.get
Callable(*args: List[Any], **kwargs: Dict[str, Any]) -> Any
at: src.external.github_api.graphql.template
get_query_limit(access_token: str) -> int
at: src.packaging.user
main(user_id: str, access_token: str, start_date: date, end_date: date, timezone_str: str="US/Eastern") -> UserPackage
at: src.utils
async_fail_gracefully(func: Callable[..., Any])
use_time_range(time_range: str, start_date: date, end_date: date) -> Tuple[date, date, str]
===========changed ref 0===========
# module: backend.src.constants
# GLOBAL
PROD = os.getenv("PROD", "False") == "True"
DOCKER = os.getenv("DOCKER", "False") == "True"
PROJECT_ID = "github-298920"
BACKEND_URL = "https://api.githubtrends.io" if PROD else "http://localhost:8000"
# API
TIMEOUT = 15 # max seconds to wait for api response
+ NODE_CHUNK_SIZE = 100 # number of nodes (commits) to query (max 100)
- NODE_CHUNK_SIZE = 20 # number of nodes (commits) to query (max 100)
+ NODE_THREADS = 10 # number of node queries simultaneously (avoid blacklisting)
- NODE_THREADS = 20 # number of node queries simultaneously (avoid blacklisting)
CUTOFF = 500 # if > cutoff lines, assume imported, don't count
# CUSTOMIZATION
BLACKLIST = ["Jupyter Notebook", "HTML"] # languages to ignore
# OAUTH
OAUTH_CLIENT_ID = os.getenv("OAUTH_CLIENT_ID", "") # client ID for GitHub OAuth App
OAUTH_CLIENT_SECRET = os.getenv("OAUTH_CLIENT_SECRET", "") # client secret for App
OAUTH_REDIRECT_URI = os.getenv("OAUTH_REDIRECT_URI", "") # redirect uri for App
# PUBSUB
PUBSUB_PUB = os.getenv("PUBSUB_PUB", "False") == "True"
PUBSUB_TOKEN = os.getenv("PUBSUB_TOKEN", "")
LOCAL_SUBSCRIBER = ( # based on name of Docker container
"http://" + ("subscriber" if DOCKER else "localhost") + ":8001/pubsub/sub/"
)
# MONGODB
MONGODB_PASSWORD = os.getenv("MONGODB_PASSWORD", "")
# SENTRY
SENTRY_DSN = os.getenv("SENTRY_DSN", "")
# TESTING
TEST_USER_ID = "AshishGupta938" # for testing, previously "avgupta456"</s>
===========changed ref 1===========
# module: backend.src.constants
# offset: 1
<s>
TEST_USER_ID = "AshishGupta938" # for testing, previously "avgupta456"
TEST_TOKEN = os.getenv("AUTH_TOKEN", "") # for authentication
|
backend.src.external.github_api.graphql.template/get_template
|
Modified
|
avgupta456~github-trends
|
b9f8685611d399e39870f1e882e224694073f678
|
add query rate limit to dev endpoint
|
<3>:<add>
<add> if calc_rate_limit:
<add> query_rate_limit = """
<add> rateLimit {
<add> limit
<add> cost
<add> remaining
<add> resetAt
<add> """
<add>
<add> query_split = query["query"].split("}")
<add> query["query"] = "}".join(
<add> query_split[:-2] + [query_rate_limit] + query_split[-2:]
<add> )
<28>:<add>
<add> if calc_rate_limit:
<add> print(data["data"]["rateLimit"])
<add>
|
# module: backend.src.external.github_api.graphql.template
+ def get_template(
+ query: Dict[str, Any], access_token: str, calc_rate_limit: bool = False
+ ) -> Dict[str, Any]:
- def get_template(query: Dict[str, Any], access_token: str) -> Dict[str, Any]:
<0> """Template for interacting with the GitHub GraphQL API"""
<1> start = datetime.now()
<2> headers: Dict[str, str] = {"Authorization": "bearer " + access_token}
<3>
<4> try:
<5> r = s.post( # type: ignore
<6> "https://api.github.com/graphql",
<7> json=query,
<8> headers=headers,
<9> timeout=TIMEOUT,
<10> )
<11> except ReadTimeout:
<12> raise GraphQLErrorTimeout("GraphQL Error: Request Timeout")
<13>
<14> print("GraphQL", datetime.now() - start)
<15> if r.status_code == 200:
<16> data = r.json() # type: ignore
<17> if "errors" in data:
<18> if (
<19> "type" in data["errors"][0]
<20> and data["errors"][0]["type"] == "SERVICE_UNAVAILABLE"
<21> and "path" in data["errors"][0]
<22> and isinstance(data["errors"][0]["path"], list)
<23> and len(data["errors"][0]["path"]) == 3 # type: ignore
<24> and data["errors"][0]["path"][0] == "nodes"
<25> ):
<26> raise GraphQLErrorMissingNode(node=int(data["errors"][0]["path"][1])) # type: ignore
<27> raise GraphQLError("GraphQL Error: " + str(data["errors"]))
<28> return data
<29>
<30> if r.status_code in [401, 403]:
<31> raise GraphQLErrorAuth("GraphQL Error: Unauthorized")
<32>
<33> if r.status_code == 502:
<34> raise GraphQLErrorTimeout("GraphQL Error: Request Timeout</s>
|
===========below chunk 0===========
# module: backend.src.external.github_api.graphql.template
+ def get_template(
+ query: Dict[str, Any], access_token: str, calc_rate_limit: bool = False
+ ) -> Dict[str, Any]:
- def get_template(query: Dict[str, Any], access_token: str) -> Dict[str, Any]:
# offset: 1
raise GraphQLError("GraphQL Error: " + str(r.status_code))
===========unchanged ref 0===========
at: backend.src.external.github_api.graphql.template
s = requests.session()
GraphQLErrorTimeout(*args: object)
at: datetime
datetime()
at: datetime.datetime
__slots__ = date.__slots__ + time.__slots__
now(tz: Optional[_tzinfo]=...) -> _S
__radd__ = __add__
at: requests.exceptions
ReadTimeout(*args, **kwargs)
at: requests.models.Response
__attrs__ = [
"_content",
"status_code",
"headers",
"url",
"history",
"encoding",
"reason",
"cookies",
"elapsed",
"request",
]
json(**kwargs) -> Any
at: requests.models.Response.__init__
self.status_code = None
at: requests.sessions.Session
__attrs__ = [
"headers",
"cookies",
"auth",
"proxies",
"hooks",
"params",
"verify",
"cert",
"adapters",
"stream",
"trust_env",
"max_redirects",
]
post(url: Union[Text, bytes], data: _Data=..., json: Optional[Any]=..., **kwargs) -> Response
at: src.constants
TIMEOUT = 15 # max seconds to wait for api response
at: typing
Dict = _alias(dict, 2, inst=False, name='Dict')
===========changed ref 0===========
<s>user_id}", status_code=status.HTTP_200_OK)
@async_fail_gracefully
async def get_user_raw(
response: Response,
user_id: str,
access_token: Optional[str] = None,
start_date: date = date.today() - timedelta(365),
end_date: date = date.today(),
time_range: str = "one_month",
timezone_str: str = "US/Eastern",
) -> UserPackage:
new_access_token: str = access_token if access_token else ""
if not access_token:
db_user = await get_user_by_user_id(user_id, use_cache=False)
if db_user is None or db_user.access_token == "":
raise LookupError("Invalid UserId")
new_access_token = db_user.access_token
+ start_query_limit = get_query_limit(access_token=new_access_token)
start_date, end_date, _ = use_time_range(time_range, start_date, end_date)
print(start_date, end_date, user_id, new_access_token, timezone_str)
data = await get_data(user_id, new_access_token, start_date, end_date, timezone_str)
+ end_query_limit = get_query_limit(access_token=new_access_token)
+ print("query limit used", start_query_limit - end_query_limit)
+ print("query limit remaining", end_query_limit)
return data
===========changed ref 1===========
# module: backend.src.constants
# GLOBAL
PROD = os.getenv("PROD", "False") == "True"
DOCKER = os.getenv("DOCKER", "False") == "True"
PROJECT_ID = "github-298920"
BACKEND_URL = "https://api.githubtrends.io" if PROD else "http://localhost:8000"
# API
TIMEOUT = 15 # max seconds to wait for api response
+ NODE_CHUNK_SIZE = 100 # number of nodes (commits) to query (max 100)
- NODE_CHUNK_SIZE = 20 # number of nodes (commits) to query (max 100)
+ NODE_THREADS = 10 # number of node queries simultaneously (avoid blacklisting)
- NODE_THREADS = 20 # number of node queries simultaneously (avoid blacklisting)
CUTOFF = 500 # if > cutoff lines, assume imported, don't count
# CUSTOMIZATION
BLACKLIST = ["Jupyter Notebook", "HTML"] # languages to ignore
# OAUTH
OAUTH_CLIENT_ID = os.getenv("OAUTH_CLIENT_ID", "") # client ID for GitHub OAuth App
OAUTH_CLIENT_SECRET = os.getenv("OAUTH_CLIENT_SECRET", "") # client secret for App
OAUTH_REDIRECT_URI = os.getenv("OAUTH_REDIRECT_URI", "") # redirect uri for App
# PUBSUB
PUBSUB_PUB = os.getenv("PUBSUB_PUB", "False") == "True"
PUBSUB_TOKEN = os.getenv("PUBSUB_TOKEN", "")
LOCAL_SUBSCRIBER = ( # based on name of Docker container
"http://" + ("subscriber" if DOCKER else "localhost") + ":8001/pubsub/sub/"
)
# MONGODB
MONGODB_PASSWORD = os.getenv("MONGODB_PASSWORD", "")
# SENTRY
SENTRY_DSN = os.getenv("SENTRY_DSN", "")
# TESTING
TEST_USER_ID = "AshishGupta938" # for testing, previously "avgupta456"</s>
===========changed ref 2===========
# module: backend.src.constants
# offset: 1
<s>
TEST_USER_ID = "AshishGupta938" # for testing, previously "avgupta456"
TEST_TOKEN = os.getenv("AUTH_TOKEN", "") # for authentication
|
backend.src.routers.auth/redirect_public
|
Modified
|
avgupta456~github-trends
|
97252c3e56531fc0b0ff825270f684edd6ff6f35
|
move decorators, redirect lookup error to auth
|
<0>:<del> url = (
<1>:<del> "https://github.com/login/oauth/authorize?client_id="
<2>:<del> + OAUTH_CLIENT_ID
<3>:<del> + "&redirect_uri="
<4>:<del> + OAUTH_REDIRECT_URI
<5>:<del> + "/redirect_backend"
<6>:<del> )
<7>:<del> return RedirectResponse(url)
<8>:<add> return RedirectResponse(get_redirect_url(private=False, user_id=user_id))
|
# module: backend.src.routers.auth
@router.get("/signup/public")
+ def redirect_public(user_id: Optional[str] = None) -> Any:
- async def redirect_public() -> Any:
<0> url = (
<1> "https://github.com/login/oauth/authorize?client_id="
<2> + OAUTH_CLIENT_ID
<3> + "&redirect_uri="
<4> + OAUTH_REDIRECT_URI
<5> + "/redirect_backend"
<6> )
<7> return RedirectResponse(url)
<8>
|
===========unchanged ref 0===========
at: backend.src.routers.auth
router = APIRouter()
at: src.utils
get_redirect_url(private: bool=False, user_id: Optional[str]=None) -> str
===========changed ref 0===========
+ # module: backend.src.decorators
+
+
===========changed ref 1===========
# module: backend.src.utils
+ def get_redirect_url(private: bool = False, user_id: Optional[str] = None) -> str:
+ url = (
+ "https://github.com/login/oauth/authorize?client_id="
+ + OAUTH_CLIENT_ID
+ + "&redirect_uri="
+ + OAUTH_REDIRECT_URI
+ + "/redirect_backend"
+ )
+ if private:
+ url += "&scope=user,repo"
+ if user_id is not None:
+ url += "&login=" + user_id
+ return url
+
===========changed ref 2===========
+ # module: backend.src.decorators
+ def fail_gracefully(func: Callable[..., Any]):
+ @wraps(func) # needed to play nice with FastAPI decorator
+ def wrapper(response: Response, *args: List[Any], **kwargs: Dict[str, Any]) -> Any:
+ start = datetime.now()
+ try:
+ data = func(response, *args, **kwargs)
+ return {"data": data, "message": "200 OK", "time": datetime.now() - start}
+ except Exception as e:
+ logging.exception(e)
+ response.status_code = status.HTTP_500_INTERNAL_SERVER_ERROR
+ return {
+ "data": [],
+ "message": "Error " + str(e),
+ "time": datetime.now() - start,
+ }
+
+ return wrapper
+
===========changed ref 3===========
+ # module: backend.src.decorators
+ # NOTE: returns HTTP_200_OK regardless to avoid retrying PubSub API
+ def pubsub_fail_gracefully(func: Callable[..., Any]):
+ @wraps(func) # needed to play nice with FastAPI decorator
+ async def wrapper(
+ response: Response, *args: List[Any], **kwargs: Dict[str, Any]
+ ) -> Any:
+ start = datetime.now()
+ try:
+ data = await func(response, *args, **kwargs)
+ return {"data": data, "message": "200 OK", "time": datetime.now() - start}
+ except Exception as e:
+ logging.exception(e)
+ response.status_code = status.HTTP_200_OK
+ return {
+ "data": [],
+ "message": "Error " + str(e),
+ "time": datetime.now() - start,
+ }
+
+ return wrapper
+
===========changed ref 4===========
+ # module: backend.src.decorators
+ def async_fail_gracefully(func: Callable[..., Any]):
+ @wraps(func) # needed to play nice with FastAPI decorator
+ async def wrapper(
+ response: Response, *args: List[Any], **kwargs: Dict[str, Any]
+ ) -> Any:
+ start = datetime.now()
+ try:
+ data = await func(response, *args, **kwargs)
+ return {"data": data, "message": "200 OK", "time": datetime.now() - start}
+ except Exception as e:
+ logging.exception(e)
+ response.status_code = status.HTTP_500_INTERNAL_SERVER_ERROR
+ return {
+ "data": [],
+ "message": "Error " + str(e),
+ "time": datetime.now() - start,
+ }
+
+ return wrapper
+
===========changed ref 5===========
# module: backend.src.utils
- def fail_gracefully(func: Callable[..., Any]):
- @wraps(func) # needed to play nice with FastAPI decorator
- def wrapper(response: Response, *args: List[Any], **kwargs: Dict[str, Any]) -> Any:
- start = datetime.now()
- try:
- data = func(response, *args, **kwargs)
- return {"data": data, "message": "200 OK", "time": datetime.now() - start}
- except Exception as e:
- logging.exception(e)
- response.status_code = status.HTTP_500_INTERNAL_SERVER_ERROR
- return {
- "data": [],
- "message": "Error " + str(e),
- "time": datetime.now() - start,
- }
-
- return wrapper
-
===========changed ref 6===========
# module: backend.src.utils
- # NOTE: returns HTTP_200_OK regardless to avoid retrying PubSub API
- def pubsub_fail_gracefully(func: Callable[..., Any]):
- @wraps(func) # needed to play nice with FastAPI decorator
- async def wrapper(
- response: Response, *args: List[Any], **kwargs: Dict[str, Any]
- ) -> Any:
- start = datetime.now()
- try:
- data = await func(response, *args, **kwargs)
- return {"data": data, "message": "200 OK", "time": datetime.now() - start}
- except Exception as e:
- logging.exception(e)
- response.status_code = status.HTTP_200_OK
- return {
- "data": [],
- "message": "Error " + str(e),
- "time": datetime.now() - start,
- }
-
- return wrapper
-
===========changed ref 7===========
# module: backend.src.utils
- def async_fail_gracefully(func: Callable[..., Any]):
- @wraps(func) # needed to play nice with FastAPI decorator
- async def wrapper(
- response: Response, *args: List[Any], **kwargs: Dict[str, Any]
- ) -> Any:
- start = datetime.now()
- try:
- data = await func(response, *args, **kwargs)
- return {"data": data, "message": "200 OK", "time": datetime.now() - start}
- except Exception as e:
- logging.exception(e)
- response.status_code = status.HTTP_500_INTERNAL_SERVER_ERROR
- return {
- "data": [],
- "message": "Error " + str(e),
- "time": datetime.now() - start,
- }
-
- return wrapper
-
===========changed ref 8===========
# module: backend.src.utils
- # NOTE: implied async, sync not implemented yet
- def svg_fail_gracefully(func: Callable[..., Any]):
- @wraps(func) # needed to play nice with FastAPI decorator
- async def wrapper(
- response: Response, *args: List[Any], **kwargs: Dict[str, Any]
- ) -> Any:
- d: Drawing
- status_code: int
- start = datetime.now()
- try:
- d = await func(response, *args, **kwargs)
- status_code = status.HTTP_200_OK
- except Exception as e:
- logging.exception(e)
- d = get_error_svg()
- status_code = status.HTTP_200_OK
-
- sio = io.StringIO()
- d.write(sio) # type: ignore
-
- print(datetime.now() - start)
-
- return Response(
- sio.getvalue(), media_type="image/svg+xml", status_code=status_code
- )
-
- return wrapper
-
|
backend.src.routers.auth/redirect_private
|
Modified
|
avgupta456~github-trends
|
97252c3e56531fc0b0ff825270f684edd6ff6f35
|
move decorators, redirect lookup error to auth
|
<0>:<del> url = (
<1>:<del> "https://github.com/login/oauth/authorize?scope=user,repo&client_id="
<2>:<del> + OAUTH_CLIENT_ID
<3>:<del> + "&redirect_uri="
<4>:<del> + OAUTH_REDIRECT_URI
<5>:<del> + "/redirect_backend"
<6>:<del> )
<7>:<del> return RedirectResponse(url)
<8>:<add> return RedirectResponse(get_redirect_url(private=True, user_id=user_id))
|
# module: backend.src.routers.auth
@router.get("/singup/private")
+ def redirect_private(user_id: Optional[str] = None) -> Any:
- async def redirect_private() -> Any:
<0> url = (
<1> "https://github.com/login/oauth/authorize?scope=user,repo&client_id="
<2> + OAUTH_CLIENT_ID
<3> + "&redirect_uri="
<4> + OAUTH_REDIRECT_URI
<5> + "/redirect_backend"
<6> )
<7> return RedirectResponse(url)
<8>
|
===========changed ref 0===========
# module: backend.src.routers.auth
@router.get("/signup/public")
+ def redirect_public(user_id: Optional[str] = None) -> Any:
- async def redirect_public() -> Any:
- url = (
- "https://github.com/login/oauth/authorize?client_id="
- + OAUTH_CLIENT_ID
- + "&redirect_uri="
- + OAUTH_REDIRECT_URI
- + "/redirect_backend"
- )
- return RedirectResponse(url)
+ return RedirectResponse(get_redirect_url(private=False, user_id=user_id))
===========changed ref 1===========
+ # module: backend.src.decorators
+
+
===========changed ref 2===========
# module: backend.src.utils
+ def get_redirect_url(private: bool = False, user_id: Optional[str] = None) -> str:
+ url = (
+ "https://github.com/login/oauth/authorize?client_id="
+ + OAUTH_CLIENT_ID
+ + "&redirect_uri="
+ + OAUTH_REDIRECT_URI
+ + "/redirect_backend"
+ )
+ if private:
+ url += "&scope=user,repo"
+ if user_id is not None:
+ url += "&login=" + user_id
+ return url
+
===========changed ref 3===========
+ # module: backend.src.decorators
+ def fail_gracefully(func: Callable[..., Any]):
+ @wraps(func) # needed to play nice with FastAPI decorator
+ def wrapper(response: Response, *args: List[Any], **kwargs: Dict[str, Any]) -> Any:
+ start = datetime.now()
+ try:
+ data = func(response, *args, **kwargs)
+ return {"data": data, "message": "200 OK", "time": datetime.now() - start}
+ except Exception as e:
+ logging.exception(e)
+ response.status_code = status.HTTP_500_INTERNAL_SERVER_ERROR
+ return {
+ "data": [],
+ "message": "Error " + str(e),
+ "time": datetime.now() - start,
+ }
+
+ return wrapper
+
===========changed ref 4===========
+ # module: backend.src.decorators
+ # NOTE: returns HTTP_200_OK regardless to avoid retrying PubSub API
+ def pubsub_fail_gracefully(func: Callable[..., Any]):
+ @wraps(func) # needed to play nice with FastAPI decorator
+ async def wrapper(
+ response: Response, *args: List[Any], **kwargs: Dict[str, Any]
+ ) -> Any:
+ start = datetime.now()
+ try:
+ data = await func(response, *args, **kwargs)
+ return {"data": data, "message": "200 OK", "time": datetime.now() - start}
+ except Exception as e:
+ logging.exception(e)
+ response.status_code = status.HTTP_200_OK
+ return {
+ "data": [],
+ "message": "Error " + str(e),
+ "time": datetime.now() - start,
+ }
+
+ return wrapper
+
===========changed ref 5===========
+ # module: backend.src.decorators
+ def async_fail_gracefully(func: Callable[..., Any]):
+ @wraps(func) # needed to play nice with FastAPI decorator
+ async def wrapper(
+ response: Response, *args: List[Any], **kwargs: Dict[str, Any]
+ ) -> Any:
+ start = datetime.now()
+ try:
+ data = await func(response, *args, **kwargs)
+ return {"data": data, "message": "200 OK", "time": datetime.now() - start}
+ except Exception as e:
+ logging.exception(e)
+ response.status_code = status.HTTP_500_INTERNAL_SERVER_ERROR
+ return {
+ "data": [],
+ "message": "Error " + str(e),
+ "time": datetime.now() - start,
+ }
+
+ return wrapper
+
===========changed ref 6===========
# module: backend.src.utils
- def fail_gracefully(func: Callable[..., Any]):
- @wraps(func) # needed to play nice with FastAPI decorator
- def wrapper(response: Response, *args: List[Any], **kwargs: Dict[str, Any]) -> Any:
- start = datetime.now()
- try:
- data = func(response, *args, **kwargs)
- return {"data": data, "message": "200 OK", "time": datetime.now() - start}
- except Exception as e:
- logging.exception(e)
- response.status_code = status.HTTP_500_INTERNAL_SERVER_ERROR
- return {
- "data": [],
- "message": "Error " + str(e),
- "time": datetime.now() - start,
- }
-
- return wrapper
-
===========changed ref 7===========
# module: backend.src.utils
- # NOTE: returns HTTP_200_OK regardless to avoid retrying PubSub API
- def pubsub_fail_gracefully(func: Callable[..., Any]):
- @wraps(func) # needed to play nice with FastAPI decorator
- async def wrapper(
- response: Response, *args: List[Any], **kwargs: Dict[str, Any]
- ) -> Any:
- start = datetime.now()
- try:
- data = await func(response, *args, **kwargs)
- return {"data": data, "message": "200 OK", "time": datetime.now() - start}
- except Exception as e:
- logging.exception(e)
- response.status_code = status.HTTP_200_OK
- return {
- "data": [],
- "message": "Error " + str(e),
- "time": datetime.now() - start,
- }
-
- return wrapper
-
===========changed ref 8===========
# module: backend.src.utils
- def async_fail_gracefully(func: Callable[..., Any]):
- @wraps(func) # needed to play nice with FastAPI decorator
- async def wrapper(
- response: Response, *args: List[Any], **kwargs: Dict[str, Any]
- ) -> Any:
- start = datetime.now()
- try:
- data = await func(response, *args, **kwargs)
- return {"data": data, "message": "200 OK", "time": datetime.now() - start}
- except Exception as e:
- logging.exception(e)
- response.status_code = status.HTTP_500_INTERNAL_SERVER_ERROR
- return {
- "data": [],
- "message": "Error " + str(e),
- "time": datetime.now() - start,
- }
-
- return wrapper
-
===========changed ref 9===========
# module: backend.src.utils
- # NOTE: implied async, sync not implemented yet
- def svg_fail_gracefully(func: Callable[..., Any]):
- @wraps(func) # needed to play nice with FastAPI decorator
- async def wrapper(
- response: Response, *args: List[Any], **kwargs: Dict[str, Any]
- ) -> Any:
- d: Drawing
- status_code: int
- start = datetime.now()
- try:
- d = await func(response, *args, **kwargs)
- status_code = status.HTTP_200_OK
- except Exception as e:
- logging.exception(e)
- d = get_error_svg()
- status_code = status.HTTP_200_OK
-
- sio = io.StringIO()
- d.write(sio) # type: ignore
-
- print(datetime.now() - start)
-
- return Response(
- sio.getvalue(), media_type="image/svg+xml", status_code=status_code
- )
-
- return wrapper
-
|
backend.src.utils/get_redirect_url
|
Modified
|
avgupta456~github-trends
|
1605e160775f656805ce737781cf3b3322c5c9ff
|
finish redirection auth
|
<5>:<add> + "/redirect"
<del> + "/redirect_backend"
|
# module: backend.src.utils
def get_redirect_url(private: bool = False, user_id: Optional[str] = None) -> str:
<0> url = (
<1> "https://github.com/login/oauth/authorize?client_id="
<2> + OAUTH_CLIENT_ID
<3> + "&redirect_uri="
<4> + OAUTH_REDIRECT_URI
<5> + "/redirect_backend"
<6> )
<7> if private:
<8> url += "&scope=user,repo"
<9> if user_id is not None:
<10> url += "&login=" + user_id
<11> return url
<12>
|
===========unchanged ref 0===========
at: src.constants
OAUTH_CLIENT_ID = os.getenv("OAUTH_CLIENT_ID", "") # client ID for GitHub OAuth App
OAUTH_REDIRECT_URI = os.getenv("OAUTH_REDIRECT_URI", "") # redirect uri for App
|
backend.src.routers.pubsub/sub_user
|
Modified
|
avgupta456~github-trends
|
dbff567c0f1749371dd0ebb7e24ae4d375725b8e
|
remove five year option
|
<4>:<add> # standard policy is to check past year of data
<del> # standard policy is to check past five years of data
<5>:<add> start_date = date.today() - timedelta(365)
<del> start_date = date.today() - timedelta(365 * 5)
<10>:<add> # don't query full history each time, instead
<del> # don't query full five years each time, instead
<12>:<add>
<add> # TODO: improve performance to store > 1 year
<add> # ideally five years, leads to issues currently
|
# module: backend.src.routers.pubsub
@router.post("/sub/user/{token}", status_code=status.HTTP_200_OK)
@pubsub_fail_gracefully
async def sub_user(response: Response, token: str, request: Request) -> Any:
<0> data: Dict[str, Any] = await parse_request(token, request)
<1>
<2> await lock_user(data["user_id"])
<3>
<4> # standard policy is to check past five years of data
<5> start_date = date.today() - timedelta(365 * 5)
<6> end_date = date.today()
<7> timezone_str = "US/Eastern"
<8>
<9> # TODO: historical data is never updated,
<10> # don't query full five years each time, instead
<11> # define function to build on previous results
<12>
<13> output = await get_data(
<14> data["user_id"],
<15> data["access_token"],
<16> start_date,
<17> end_date,
<18> timezone_str,
<19> )
<20>
<21> await update_user(data["user_id"], output)
<22>
<23> await unlock_user(data["user_id"])
<24>
<25> return data
<26>
|
===========unchanged ref 0===========
at: backend.src.routers.pubsub
router = APIRouter()
at: datetime
timedelta(days: float=..., seconds: float=..., microseconds: float=..., milliseconds: float=..., minutes: float=..., hours: float=..., weeks: float=..., *, fold: int=...)
date()
at: datetime.date
__slots__ = '_year', '_month', '_day', '_hashcode'
today() -> _S
__str__ = isoformat
__radd__ = __add__
at: src.db.functions.users
lock_user(user_id: str) -> None
update_user(user_id: str, raw_data: Optional[UserPackage]=None) -> None
at: src.decorators
pubsub_fail_gracefully(func: Callable[..., Any])
at: src.external.pubsub.templates
parse_request(token: str, request: Request) -> Dict[str, Any]
at: src.packaging.user
main(user_id: str, access_token: str, start_date: date, end_date: date, timezone_str: str="US/Eastern") -> UserPackage
at: typing
Dict = _alias(dict, 2, inst=False, name='Dict')
|
backend.src.utils/use_time_range
|
Modified
|
avgupta456~github-trends
|
dbff567c0f1749371dd0ebb7e24ae4d375725b8e
|
remove five year option
|
<2>:<add> "three_months": (90, "Past 3 Months"),
<4>:<del> "five_years": (365 * 5, "Past 5 Years"),
|
# module: backend.src.utils
# returns start date, end date, string representing time range
def use_time_range(
time_range: str, start_date: date, end_date: date
) -> Tuple[date, date, str]:
<0> duration_options = {
<1> "one_month": (30, "Past 1 Month"),
<2> "six_months": (180, "Past 6 Months"),
<3> "one_year": (365, "Past 1 Year"),
<4> "five_years": (365 * 5, "Past 5 Years"),
<5> }
<6>
<7> start_str = start_date.strftime("X%m/X%d/%Y").replace("X0", "X").replace("X", "")
<8> end_str = end_date.strftime("X%m/X%d/%Y").replace("X0", "X").replace("X", "")
<9> if end_date == date.today():
<10> end_str = "Present"
<11> time_str = start_str + " - " + end_str
<12>
<13> if time_range in duration_options:
<14> days, time_str = duration_options[time_range]
<15> end_date = date.today()
<16> start_date = date.today() - timedelta(days)
<17>
<18> return start_date, end_date, time_str
<19>
|
===========unchanged ref 0===========
at: datetime
timedelta(days: float=..., seconds: float=..., microseconds: float=..., milliseconds: float=..., minutes: float=..., hours: float=..., weeks: float=..., *, fold: int=...)
date()
at: datetime.date
__slots__ = '_year', '_month', '_day', '_hashcode'
today() -> _S
strftime(fmt: _Text) -> str
__str__ = isoformat
__radd__ = __add__
at: typing
Tuple = _TupleType(tuple, -1, inst=False, name='Tuple')
===========changed ref 0===========
# module: backend.src.routers.pubsub
@router.post("/sub/user/{token}", status_code=status.HTTP_200_OK)
@pubsub_fail_gracefully
async def sub_user(response: Response, token: str, request: Request) -> Any:
data: Dict[str, Any] = await parse_request(token, request)
await lock_user(data["user_id"])
+ # standard policy is to check past year of data
- # standard policy is to check past five years of data
+ start_date = date.today() - timedelta(365)
- start_date = date.today() - timedelta(365 * 5)
end_date = date.today()
timezone_str = "US/Eastern"
# TODO: historical data is never updated,
+ # don't query full history each time, instead
- # don't query full five years each time, instead
# define function to build on previous results
+
+ # TODO: improve performance to store > 1 year
+ # ideally five years, leads to issues currently
output = await get_data(
data["user_id"],
data["access_token"],
start_date,
end_date,
timezone_str,
)
await update_user(data["user_id"], output)
await unlock_user(data["user_id"])
return data
|
backend.src.processing.user.commit/_get_commits_languages
|
Modified
|
avgupta456~github-trends
|
dbff567c0f1749371dd0ebb7e24ae4d375725b8e
|
remove five year option
|
<1>:<add> i, retries = 0, 0
<add> while i < len(node_ids):
<del> for i in range(0, len(node_ids), per_page):
<4>:<add> if retries < 2:
<add> all_data.extend(get_commits(access_token, node_ids[i:cutoff])) # type: ignore
<del> all_data.extend(get_commits(access_token, node_ids[i:cutoff])) # type: ignore
<5>:<add> else:
<add> all_data.extend([{} for _ in range(cutoff - i)])
<add> i, retries = i + per_page, 0
<add> except GraphQLErrorMissingNode:
<del> except GraphQLErrorMissingNode as e:
<6>:<add> print("GraphQLErrorMissingNode, retrying...")
<add> sleep(1)
<add> retries += 1
<del> curr = node_ids[i:cutoff]
<7>:<del> curr.pop(e.node)
<8>:<del> all_data.extend(_get_commits_languages(access_token, curr))
<10>:<add> print("GraphQLErrorTimeout, retrying...")
<add> sleep(1)
<add> retries += 1
<del> length = cutoff - i
<11>:<del> print("Commit Timeout Exception:", length, " nodes lost")
<12>:<del> all_data.extend([{} for _ in range(length)])
<14>:<add> print("GraphQLErrorAuth, retrying...")
<add> sleep(1)
<add> retries += 1
<del> length = cutoff - i
<15>:<del> print("Commit Auth Exception:", length, " nodes lost")
<16>:<del> all_data.extend([{} for _ in range(length)])
|
# module: backend.src.processing.user.commit
def _get_commits_languages(
access_token: str, node_ids: List[str], per_page: int = NODE_CHUNK_SIZE
) -> List[Dict[str, Any]]:
<0> all_data: List[Dict[str, Any]] = []
<1> for i in range(0, len(node_ids), per_page):
<2> cutoff = min(len(node_ids), i + per_page)
<3> try:
<4> all_data.extend(get_commits(access_token, node_ids[i:cutoff])) # type: ignore
<5> except GraphQLErrorMissingNode as e:
<6> curr = node_ids[i:cutoff]
<7> curr.pop(e.node)
<8> all_data.extend(_get_commits_languages(access_token, curr))
<9> except GraphQLErrorTimeout:
<10> length = cutoff - i
<11> print("Commit Timeout Exception:", length, " nodes lost")
<12> all_data.extend([{} for _ in range(length)])
<13> except GraphQLErrorAuth:
<14> length = cutoff - i
<15> print("Commit Auth Exception:", length, " nodes lost")
<16> all_data.extend([{} for _ in range(length)])
<17>
<18> return all_data
<19>
|
===========unchanged ref 0===========
at: src.constants
NODE_CHUNK_SIZE = 100 # number of nodes (commits) to query (max 100)
at: src.external.github_api.graphql.commit
get_commits(access_token: str, node_ids: List[str]) -> Union[Dict[str, Any], List[Any]]
at: src.external.github_api.graphql.template
GraphQLErrorMissingNode(node: int)
GraphQLErrorTimeout(*args: object)
at: time
sleep(secs: float) -> None
at: typing
List = _alias(list, 1, inst=False, name='List')
Dict = _alias(dict, 2, inst=False, name='Dict')
===========changed ref 0===========
# module: backend.src.routers.pubsub
@router.post("/sub/user/{token}", status_code=status.HTTP_200_OK)
@pubsub_fail_gracefully
async def sub_user(response: Response, token: str, request: Request) -> Any:
data: Dict[str, Any] = await parse_request(token, request)
await lock_user(data["user_id"])
+ # standard policy is to check past year of data
- # standard policy is to check past five years of data
+ start_date = date.today() - timedelta(365)
- start_date = date.today() - timedelta(365 * 5)
end_date = date.today()
timezone_str = "US/Eastern"
# TODO: historical data is never updated,
+ # don't query full history each time, instead
- # don't query full five years each time, instead
# define function to build on previous results
+
+ # TODO: improve performance to store > 1 year
+ # ideally five years, leads to issues currently
output = await get_data(
data["user_id"],
data["access_token"],
start_date,
end_date,
timezone_str,
)
await update_user(data["user_id"], output)
await unlock_user(data["user_id"])
return data
===========changed ref 1===========
# module: backend.src.utils
# returns start date, end date, string representing time range
def use_time_range(
time_range: str, start_date: date, end_date: date
) -> Tuple[date, date, str]:
duration_options = {
"one_month": (30, "Past 1 Month"),
+ "three_months": (90, "Past 3 Months"),
"six_months": (180, "Past 6 Months"),
"one_year": (365, "Past 1 Year"),
- "five_years": (365 * 5, "Past 5 Years"),
}
start_str = start_date.strftime("X%m/X%d/%Y").replace("X0", "X").replace("X", "")
end_str = end_date.strftime("X%m/X%d/%Y").replace("X0", "X").replace("X", "")
if end_date == date.today():
end_str = "Present"
time_str = start_str + " - " + end_str
if time_range in duration_options:
days, time_str = duration_options[time_range]
end_date = date.today()
start_date = date.today() - timedelta(days)
return start_date, end_date, time_str
===========changed ref 2===========
# module: backend.src.constants
# GLOBAL
PROD = os.getenv("PROD", "False") == "True"
DOCKER = os.getenv("DOCKER", "False") == "True"
PROJECT_ID = "github-298920"
BACKEND_URL = "https://api.githubtrends.io" if PROD else "http://localhost:8000"
# API
# https://docs.github.com/en/rest/reference/rate-limit
# https://docs.github.com/en/rest/guides/best-practices-for-integrators#dealing-with-secondary-rate-limits
# https://docs.github.com/en/graphql/overview/resource-limitations
TIMEOUT = 10 # max seconds to wait for api response
+ NODE_CHUNK_SIZE = 100 # number of nodes (commits) to query (max 100)
- NODE_CHUNK_SIZE = 80 # number of nodes (commits) to query (max 100)
+ NODE_THREADS = 10 # number of node queries simultaneously (avoid blacklisting)
- NODE_THREADS = 5 # number of node queries simultaneously (avoid blacklisting)
CUTOFF = 500 # if > cutoff lines, assume imported, don't count
# CUSTOMIZATION
BLACKLIST = ["Jupyter Notebook", "HTML"] # languages to ignore
# OAUTH
OAUTH_CLIENT_ID = os.getenv("OAUTH_CLIENT_ID", "") # client ID for GitHub OAuth App
OAUTH_CLIENT_SECRET = os.getenv("OAUTH_CLIENT_SECRET", "") # client secret for App
OAUTH_REDIRECT_URI = os.getenv("OAUTH_REDIRECT_URI", "") # redirect uri for App
# PUBSUB
PUBSUB_PUB = os.getenv("PUBSUB_PUB", "False") == "True"
PUBSUB_TOKEN = os.getenv("PUBSUB_TOKEN", "")
LOCAL_SUBSCRIBER = ( # based on name of Docker container
"http://" + ("subscriber" if DOCKER else "localhost") + ":8001/pubsub/sub/"
)
# MONGODB
</s>
===========changed ref 3===========
# module: backend.src.constants
# offset: 1
<s>subscriber" if DOCKER else "localhost") + ":8001/pubsub/sub/"
)
# MONGODB
MONGODB_PASSWORD = os.getenv("MONGODB_PASSWORD", "")
# SENTRY
SENTRY_DSN = os.getenv("SENTRY_DSN", "")
# TESTING
TEST_USER_ID = "AshishGupta938" # for testing, previously "avgupta456"
TEST_TOKEN = os.getenv("AUTH_TOKEN", "") # for authentication
|
backend.src.routers.auth/redirect_return
|
Modified
|
avgupta456~github-trends
|
dbff567c0f1749371dd0ebb7e24ae4d375725b8e
|
remove five year option
|
<2>:<del> return (
<3>:<del> "Authenticated "
<4>:<del> + user_id
<5>:<del> + "! Please continue following instructions in the README."
<6>:<del> )
<7>:<add> return RedirectResponse(BACKEND_URL + "/auth/redirect_success/" + user_id)
<9>:<add> return RedirectResponse(BACKEND_URL + "/auth/redirect_failure")
<del> return "Unknown Error. Please try again later."
|
# module: backend.src.routers.auth
@router.get("/redirect")
+ async def redirect_return(code: str = "") -> RedirectResponse:
- async def redirect_return(code: str = "") -> str:
<0> try:
<1> user_id = await authenticate(code=code) # type: ignore
<2> return (
<3> "Authenticated "
<4> + user_id
<5> + "! Please continue following instructions in the README."
<6> )
<7> except Exception as e:
<8> logging.exception(e)
<9> return "Unknown Error. Please try again later."
<10>
|
===========unchanged ref 0===========
at: backend.src.routers.auth
router = APIRouter()
authenticate(code: str) -> str
at: logging
exception(msg: Any, *args: Any, exc_info: _ExcInfoType=..., stack_info: bool=..., extra: Optional[Dict[str, Any]]=..., **kwargs: Any) -> None
at: src.constants
BACKEND_URL = "https://api.githubtrends.io" if PROD else "http://localhost:8000"
===========changed ref 0===========
# module: backend.src.routers.pubsub
@router.post("/sub/user/{token}", status_code=status.HTTP_200_OK)
@pubsub_fail_gracefully
async def sub_user(response: Response, token: str, request: Request) -> Any:
data: Dict[str, Any] = await parse_request(token, request)
await lock_user(data["user_id"])
+ # standard policy is to check past year of data
- # standard policy is to check past five years of data
+ start_date = date.today() - timedelta(365)
- start_date = date.today() - timedelta(365 * 5)
end_date = date.today()
timezone_str = "US/Eastern"
# TODO: historical data is never updated,
+ # don't query full history each time, instead
- # don't query full five years each time, instead
# define function to build on previous results
+
+ # TODO: improve performance to store > 1 year
+ # ideally five years, leads to issues currently
output = await get_data(
data["user_id"],
data["access_token"],
start_date,
end_date,
timezone_str,
)
await update_user(data["user_id"], output)
await unlock_user(data["user_id"])
return data
===========changed ref 1===========
# module: backend.src.utils
# returns start date, end date, string representing time range
def use_time_range(
time_range: str, start_date: date, end_date: date
) -> Tuple[date, date, str]:
duration_options = {
"one_month": (30, "Past 1 Month"),
+ "three_months": (90, "Past 3 Months"),
"six_months": (180, "Past 6 Months"),
"one_year": (365, "Past 1 Year"),
- "five_years": (365 * 5, "Past 5 Years"),
}
start_str = start_date.strftime("X%m/X%d/%Y").replace("X0", "X").replace("X", "")
end_str = end_date.strftime("X%m/X%d/%Y").replace("X0", "X").replace("X", "")
if end_date == date.today():
end_str = "Present"
time_str = start_str + " - " + end_str
if time_range in duration_options:
days, time_str = duration_options[time_range]
end_date = date.today()
start_date = date.today() - timedelta(days)
return start_date, end_date, time_str
===========changed ref 2===========
# module: backend.src.processing.user.commit
def _get_commits_languages(
access_token: str, node_ids: List[str], per_page: int = NODE_CHUNK_SIZE
) -> List[Dict[str, Any]]:
all_data: List[Dict[str, Any]] = []
+ i, retries = 0, 0
+ while i < len(node_ids):
- for i in range(0, len(node_ids), per_page):
cutoff = min(len(node_ids), i + per_page)
try:
+ if retries < 2:
+ all_data.extend(get_commits(access_token, node_ids[i:cutoff])) # type: ignore
- all_data.extend(get_commits(access_token, node_ids[i:cutoff])) # type: ignore
+ else:
+ all_data.extend([{} for _ in range(cutoff - i)])
+ i, retries = i + per_page, 0
+ except GraphQLErrorMissingNode:
- except GraphQLErrorMissingNode as e:
+ print("GraphQLErrorMissingNode, retrying...")
+ sleep(1)
+ retries += 1
- curr = node_ids[i:cutoff]
- curr.pop(e.node)
- all_data.extend(_get_commits_languages(access_token, curr))
except GraphQLErrorTimeout:
+ print("GraphQLErrorTimeout, retrying...")
+ sleep(1)
+ retries += 1
- length = cutoff - i
- print("Commit Timeout Exception:", length, " nodes lost")
- all_data.extend([{} for _ in range(length)])
except GraphQLErrorAuth:
+ print("GraphQLErrorAuth, retrying...")
+ sleep(1)
+ retries += 1
- length = cutoff - i
- print("Commit Auth Exception:", length, " nodes lost")
- all_data.extend([{} for _ in range(length)])
return all_data
===========changed ref 3===========
# module: backend.src.constants
# GLOBAL
PROD = os.getenv("PROD", "False") == "True"
DOCKER = os.getenv("DOCKER", "False") == "True"
PROJECT_ID = "github-298920"
BACKEND_URL = "https://api.githubtrends.io" if PROD else "http://localhost:8000"
# API
# https://docs.github.com/en/rest/reference/rate-limit
# https://docs.github.com/en/rest/guides/best-practices-for-integrators#dealing-with-secondary-rate-limits
# https://docs.github.com/en/graphql/overview/resource-limitations
TIMEOUT = 10 # max seconds to wait for api response
+ NODE_CHUNK_SIZE = 100 # number of nodes (commits) to query (max 100)
- NODE_CHUNK_SIZE = 80 # number of nodes (commits) to query (max 100)
+ NODE_THREADS = 10 # number of node queries simultaneously (avoid blacklisting)
- NODE_THREADS = 5 # number of node queries simultaneously (avoid blacklisting)
CUTOFF = 500 # if > cutoff lines, assume imported, don't count
# CUSTOMIZATION
BLACKLIST = ["Jupyter Notebook", "HTML"] # languages to ignore
# OAUTH
OAUTH_CLIENT_ID = os.getenv("OAUTH_CLIENT_ID", "") # client ID for GitHub OAuth App
OAUTH_CLIENT_SECRET = os.getenv("OAUTH_CLIENT_SECRET", "") # client secret for App
OAUTH_REDIRECT_URI = os.getenv("OAUTH_REDIRECT_URI", "") # redirect uri for App
# PUBSUB
PUBSUB_PUB = os.getenv("PUBSUB_PUB", "False") == "True"
PUBSUB_TOKEN = os.getenv("PUBSUB_TOKEN", "")
LOCAL_SUBSCRIBER = ( # based on name of Docker container
"http://" + ("subscriber" if DOCKER else "localhost") + ":8001/pubsub/sub/"
)
# MONGODB
</s>
===========changed ref 4===========
# module: backend.src.constants
# offset: 1
<s>subscriber" if DOCKER else "localhost") + ":8001/pubsub/sub/"
)
# MONGODB
MONGODB_PASSWORD = os.getenv("MONGODB_PASSWORD", "")
# SENTRY
SENTRY_DSN = os.getenv("SENTRY_DSN", "")
# TESTING
TEST_USER_ID = "AshishGupta938" # for testing, previously "avgupta456"
TEST_TOKEN = os.getenv("AUTH_TOKEN", "") # for authentication
|
backend.src.routers.users.svg/get_user_lang_svg
|
Modified
|
avgupta456~github-trends
|
84854cf188ab4fe437b7ecfe23ac5375067d2fe6
|
Merge branch 'main' into demo
|
<0>:<del> start_date, end_date, time_str = use_time_range(time_range, start_date, end_date)
<1>:<add> output, time_str = await svg_base(user_id, start_date, end_date, time_range, demo)
<del> output = await get_user(user_id, start_date, end_date)
<2>:<add>
<add> # if no data, return loading svg
<4>:<add>
<add> # get top languages
<add> processed, num_excluded = get_top_languages(output, loc_metric, include_private)
<del> processed, commits_excluded = get_top_languages(output, loc_metric, include_private)
<5>:<add> return get_top_langs_svg(
<del> out = get_top_langs_svg(
<6>:<add> processed, time_str, use_percent, loc_metric, num_excluded, compact
<del> processed, time_str, use_percent, loc_metric, commits_excluded, compact
<8>:<del> return out
|
<s>svg(
response: Response,
user_id: str,
start_date: date = date.today() - timedelta(30),
end_date: date = date.today(),
time_range: str = "one_year",
timezone_str: str = "US/Eastern",
use_percent: bool = False,
include_private: bool = False,
loc_metric: str = "added",
compact: bool = False,
+ demo: bool = False,
) -> Any:
<0> start_date, end_date, time_str = use_time_range(time_range, start_date, end_date)
<1> output = await get_user(user_id, start_date, end_date)
<2> if output is None:
<3> return get_loading_svg()
<4> processed, commits_excluded = get_top_languages(output, loc_metric, include_private)
<5> out = get_top_langs_svg(
<6> processed, time_str, use_percent, loc_metric, commits_excluded, compact
<7> )
<8> return out
<9>
|
===========unchanged ref 0===========
at: backend.src.routers.users.svg
router = APIRouter()
at: datetime
timedelta(days: float=..., seconds: float=..., microseconds: float=..., milliseconds: float=..., minutes: float=..., hours: float=..., weeks: float=..., *, fold: int=...)
date()
at: datetime.date
__slots__ = '_year', '_month', '_day', '_hashcode'
today() -> _S
__str__ = isoformat
__radd__ = __add__
at: src.helper.decorators
svg_fail_gracefully(func: Callable[..., Any])
at: src.helper.utils
use_time_range(time_range: str, start_date: date, end_date: date) -> Tuple[date, date, str]
at: src.routers.users.get_data
Callable(*args: List[Any], **kwargs: Dict[str, Any]) -> Any
Callable(*args: List[Any], **kwargs: Dict[str, Any]) -> Any
at: typing
Tuple = _TupleType(tuple, -1, inst=False, name='Tuple')
===========changed ref 0===========
# module: backend.src.routers.users.svg
+ def svg_base(
+ user_id: str,
+ start_date: date = date.today() - timedelta(30),
+ end_date: date = date.today(),
+ time_range: str = "one_year",
+ demo: bool = False,
+ ) -> Tuple[Optional[UserPackage], str]:
+ # process time_range, start_date, end_date
+ time_range = "one_month" if demo else time_range
+ start_date, end_date, time_str = use_time_range(time_range, start_date, end_date)
+
+ # fetch data, either using demo or user method
+ if demo:
+ output = await get_user_demo(user_id)
+ else:
+ output = await get_user(user_id, start_date, end_date)
+
+ return output, time_str
+
===========changed ref 1===========
+ # module: backend.src.db.user.compression
+
+
===========changed ref 2===========
+ # module: backend.src.db.user.get
+
+
===========changed ref 3===========
+ # module: backend.src.db.user.functions
+
+
===========changed ref 4===========
+ # module: backend.src.db.user.models
+
+
===========changed ref 5===========
+ # module: backend.src.db.secret.models
+
+
===========changed ref 6===========
+ # module: backend.src.helper.utils
+
+
===========changed ref 7===========
+ # module: backend.src.helper.decorators
+
+
===========changed ref 8===========
+ # module: backend.src.db.secret.functions
+
+
===========changed ref 9===========
+ # module: backend.src.db.user.models
+ """
+ Database Models
+ """
+
===========changed ref 10===========
+ # module: backend.src.db.user.models
+ """
+ Input Models
+ """
+
===========changed ref 11===========
+ # module: backend.src.db.user.get
+ """
+ Raw Get Methods
+ """
+
===========changed ref 12===========
+ # module: backend.src.db.user.models
+ class CreateUserModel(BaseModel):
+ user_id: str
+ access_token: str
+
===========changed ref 13===========
+ # module: backend.src.db.secret.models
+ class SecretModel(BaseModel):
+ project: str
+ access_tokens: List[str]
+
===========changed ref 14===========
+ # module: backend.src.helper.utils
+ def date_to_datetime(
+ dt: date, hour: int = 0, minute: int = 0, second: int = 0
+ ) -> datetime:
+ return datetime(dt.year, dt.month, dt.day, hour, minute, second)
+
===========changed ref 15===========
+ # module: backend.src.db.user.models
+ class UserModel(BaseModel):
+ user_id: str
+ access_token: str
+ last_updated: datetime
+ raw_data: Optional[UserPackage]
+ lock: bool
+
===========changed ref 16===========
+ # module: backend.src.db.user.functions
+ def unlock_user(user_id: str) -> None:
+ await USERS.update_one( # type: ignore
+ {"user_id": user_id},
+ {"$set": {"lock": False}},
+ )
+
===========changed ref 17===========
+ # module: backend.src.db.user.functions
+ def lock_user(user_id: str) -> None:
+ await USERS.update_one( # type: ignore
+ {"user_id": user_id},
+ {"$set": {"lock": True}},
+ )
+
===========changed ref 18===========
+ # module: backend.src.db.secret.functions
+ def get_next_key(project: str) -> str:
+ keys: List[str] = await get_keys(project)
+ if len(keys) == 0:
+ return ""
+
+ return keys[randint(0, len(keys) - 1)]
+
===========changed ref 19===========
+ # module: backend.src.db.user.functions
+ def update_user(user_id: str, raw_data: Optional[UserPackage] = None) -> None:
+ if raw_data is not None:
+ compressed_data = compress(raw_data.dict())
+ await USERS.update_one( # type: ignore
+ {"user_id": user_id},
+ {"$set": {"last_updated": datetime.now(), "raw_data": compressed_data}},
+ )
+
===========changed ref 20===========
# module: backend.src.routers.users.get_data
+ @alru_cache()
+ async def get_user_demo(user_id: str) -> UserPackage:
+ access_token = await get_next_key("demo")
+ start_date, end_date, _ = use_time_range("one_month", date.today(), date.today())
+ data = await get_data(user_id, access_token, start_date, end_date)
+ return (True, data) # type: ignore
+
===========changed ref 21===========
+ # module: backend.src.db.secret.functions
+ @alru_cache()
+ async def get_keys(project: str) -> List[str]:
+ secrets: Optional[Dict[str, Any]] = await SECRETS.find_one({"project": project}) # type: ignore
+ if secrets is None:
+ return (False, []) # type: ignore
+
+ tokens = SecretModel.parse_obj(secrets).access_tokens
+ return (True, tokens) # type: ignore
+
===========changed ref 22===========
+ # module: backend.src.helper.utils
+ def get_redirect_url(private: bool = False, user_id: Optional[str] = None) -> str:
+ url = (
+ "https://github.com/login/oauth/authorize?client_id="
+ + OAUTH_CLIENT_ID
+ + "&redirect_uri="
+ + OAUTH_REDIRECT_URI
+ + "/redirect"
+ )
+ if private:
+ url += "&scope=user,repo"
+ if user_id is not None:
+ url += "&login=" + user_id
+ return url
+
===========changed ref 23===========
+ # module: backend.src.db.user.compression
+ def compress_stats(data: Dict[str, Any]) -> Dict[str, Any]:
+ out = {
+ "counts": (
+ data["contribs_count"],
+ data["commits_count"],
+ data["issues_count"],
+ data["prs_count"],
+ data["reviews_count"],
+ data["repos_count"],
+ data["other_count"],
+ ),
+ "languages": [
+ (name, stats["color"], stats["additions"], stats["deletions"])
+ for name, stats in data["languages"].items()
+ ],
+ }
+
+ if "private" in data:
+ out["private"] = data["private"]
+
+ return out
+
|
backend.src.routers.users.svg/get_user_repo_svg
|
Modified
|
avgupta456~github-trends
|
84854cf188ab4fe437b7ecfe23ac5375067d2fe6
|
Merge branch 'main' into demo
|
<0>:<del> start_date, end_date, time_str = use_time_range(time_range, start_date, end_date)
<1>:<add> output, time_str = await svg_base(user_id, start_date, end_date, time_range, demo)
<del> output = await get_user(user_id, start_date, end_date)
<2>:<add>
<add> # if no data, return loading svg
<4>:<add>
<add> # get top repos
|
<s>
@svg_fail_gracefully
async def get_user_repo_svg(
response: Response,
user_id: str,
start_date: date = date.today() - timedelta(30),
end_date: date = date.today(),
time_range: str = "one_year",
timezone_str: str = "US/Eastern",
include_private: bool = False,
loc_metric: str = "added",
+ demo: bool = False,
) -> Any:
<0> start_date, end_date, time_str = use_time_range(time_range, start_date, end_date)
<1> output = await get_user(user_id, start_date, end_date)
<2> if output is None:
<3> return get_loading_svg()
<4> processed, commits_excluded = get_top_repos(output, loc_metric, include_private)
<5> return get_top_repos_svg(processed, time_str, loc_metric, commits_excluded)
<6>
|
===========unchanged ref 0===========
at: backend.src.routers.users.svg
svg_base(user_id: str, start_date: date=date.today() - timedelta(30), end_date: date=date.today(), time_range: str="one_year", demo: bool=False) -> Tuple[Optional[UserPackage], str]
at: datetime
timedelta(days: float=..., seconds: float=..., microseconds: float=..., milliseconds: float=..., minutes: float=..., hours: float=..., weeks: float=..., *, fold: int=...)
date()
at: datetime.date
today() -> _S
at: src.analytics.user.commits
get_top_languages(data: UserPackage, loc_metric: str, include_private: bool) -> Tuple[List[LanguageStats], int]
at: src.svg.error
get_loading_svg() -> Drawing
at: src.svg.top_langs
get_top_langs_svg(data: List[LanguageStats], time_str: str, use_percent: bool, loc_metric: str, commits_excluded: int, compact: bool) -> Drawing
===========changed ref 0===========
# module: backend.src.routers.users.svg
+ def svg_base(
+ user_id: str,
+ start_date: date = date.today() - timedelta(30),
+ end_date: date = date.today(),
+ time_range: str = "one_year",
+ demo: bool = False,
+ ) -> Tuple[Optional[UserPackage], str]:
+ # process time_range, start_date, end_date
+ time_range = "one_month" if demo else time_range
+ start_date, end_date, time_str = use_time_range(time_range, start_date, end_date)
+
+ # fetch data, either using demo or user method
+ if demo:
+ output = await get_user_demo(user_id)
+ else:
+ output = await get_user(user_id, start_date, end_date)
+
+ return output, time_str
+
===========changed ref 1===========
<s>svg(
response: Response,
user_id: str,
start_date: date = date.today() - timedelta(30),
end_date: date = date.today(),
time_range: str = "one_year",
timezone_str: str = "US/Eastern",
use_percent: bool = False,
include_private: bool = False,
loc_metric: str = "added",
compact: bool = False,
+ demo: bool = False,
) -> Any:
- start_date, end_date, time_str = use_time_range(time_range, start_date, end_date)
+ output, time_str = await svg_base(user_id, start_date, end_date, time_range, demo)
- output = await get_user(user_id, start_date, end_date)
+
+ # if no data, return loading svg
if output is None:
return get_loading_svg()
+
+ # get top languages
+ processed, num_excluded = get_top_languages(output, loc_metric, include_private)
- processed, commits_excluded = get_top_languages(output, loc_metric, include_private)
+ return get_top_langs_svg(
- out = get_top_langs_svg(
+ processed, time_str, use_percent, loc_metric, num_excluded, compact
- processed, time_str, use_percent, loc_metric, commits_excluded, compact
)
- return out
===========changed ref 2===========
+ # module: backend.src.db.user.compression
+
+
===========changed ref 3===========
+ # module: backend.src.db.user.get
+
+
===========changed ref 4===========
+ # module: backend.src.db.user.functions
+
+
===========changed ref 5===========
+ # module: backend.src.db.user.models
+
+
===========changed ref 6===========
+ # module: backend.src.db.secret.models
+
+
===========changed ref 7===========
+ # module: backend.src.helper.utils
+
+
===========changed ref 8===========
+ # module: backend.src.helper.decorators
+
+
===========changed ref 9===========
+ # module: backend.src.db.secret.functions
+
+
===========changed ref 10===========
+ # module: backend.src.db.user.models
+ """
+ Database Models
+ """
+
===========changed ref 11===========
+ # module: backend.src.db.user.models
+ """
+ Input Models
+ """
+
===========changed ref 12===========
+ # module: backend.src.db.user.get
+ """
+ Raw Get Methods
+ """
+
===========changed ref 13===========
+ # module: backend.src.db.user.models
+ class CreateUserModel(BaseModel):
+ user_id: str
+ access_token: str
+
===========changed ref 14===========
+ # module: backend.src.db.secret.models
+ class SecretModel(BaseModel):
+ project: str
+ access_tokens: List[str]
+
===========changed ref 15===========
+ # module: backend.src.helper.utils
+ def date_to_datetime(
+ dt: date, hour: int = 0, minute: int = 0, second: int = 0
+ ) -> datetime:
+ return datetime(dt.year, dt.month, dt.day, hour, minute, second)
+
===========changed ref 16===========
+ # module: backend.src.db.user.models
+ class UserModel(BaseModel):
+ user_id: str
+ access_token: str
+ last_updated: datetime
+ raw_data: Optional[UserPackage]
+ lock: bool
+
===========changed ref 17===========
+ # module: backend.src.db.user.functions
+ def unlock_user(user_id: str) -> None:
+ await USERS.update_one( # type: ignore
+ {"user_id": user_id},
+ {"$set": {"lock": False}},
+ )
+
===========changed ref 18===========
+ # module: backend.src.db.user.functions
+ def lock_user(user_id: str) -> None:
+ await USERS.update_one( # type: ignore
+ {"user_id": user_id},
+ {"$set": {"lock": True}},
+ )
+
===========changed ref 19===========
+ # module: backend.src.db.secret.functions
+ def get_next_key(project: str) -> str:
+ keys: List[str] = await get_keys(project)
+ if len(keys) == 0:
+ return ""
+
+ return keys[randint(0, len(keys) - 1)]
+
===========changed ref 20===========
+ # module: backend.src.db.user.functions
+ def update_user(user_id: str, raw_data: Optional[UserPackage] = None) -> None:
+ if raw_data is not None:
+ compressed_data = compress(raw_data.dict())
+ await USERS.update_one( # type: ignore
+ {"user_id": user_id},
+ {"$set": {"last_updated": datetime.now(), "raw_data": compressed_data}},
+ )
+
===========changed ref 21===========
# module: backend.src.routers.users.get_data
+ @alru_cache()
+ async def get_user_demo(user_id: str) -> UserPackage:
+ access_token = await get_next_key("demo")
+ start_date, end_date, _ = use_time_range("one_month", date.today(), date.today())
+ data = await get_data(user_id, access_token, start_date, end_date)
+ return (True, data) # type: ignore
+
===========changed ref 22===========
+ # module: backend.src.db.secret.functions
+ @alru_cache()
+ async def get_keys(project: str) -> List[str]:
+ secrets: Optional[Dict[str, Any]] = await SECRETS.find_one({"project": project}) # type: ignore
+ if secrets is None:
+ return (False, []) # type: ignore
+
+ tokens = SecretModel.parse_obj(secrets).access_tokens
+ return (True, tokens) # type: ignore
+
|
backend.src.svg.top_repos/get_top_repos_svg
|
Modified
|
avgupta456~github-trends
|
00b6e777e6d9b0abbea9023c77fa276019f1fef9
|
backend bug fixes
|
<14>:<add> if len(data) > 0:
<add> dataset: List[Tuple[str, str, List[Tuple[float, str]]]] = []
<del> dataset: List[Tuple[str, str, List[Tuple[float, str]]]] = []
<15>:<add> total = data[0].loc
<del> total = data[0].loc
<16>:<add> for x in data[:4]:
<del> for x in data[:4]:
<17>:<add> data_row = []
<del> data_row = []
<18>:<add> for lang in x.langs:
<del> for lang in x.langs:
<19>:<add> data_row.append((100 * lang.loc / total, lang.color))
<del> data_row.append((100 * lang.loc / total, lang.color))
<20>:<add> name = "private/repository" if x.private else x.repo
<del> name = "private/repository" if x.private else x.repo
<21>:<add> dataset.append((name, format_number(x.loc), data_row))
<del> dataset.append((name, format_number(x.loc), data_row))
<23>:<add> dp.add(get_bar_section(d=d, dataset=dataset, padding=45, bar_width=195))
<del> dp.add(get_bar_section(d=d, dataset=dataset, padding=45, bar_width=195))
<25>:<add> langs = {}
<del> langs = {}
<26>:<add> for x in data[:4]:
<del> for x in data[:4]:
<27>:<add> for lang in x.langs:
<del> for lang in x.langs:
<28>:<add> langs[lang.lang] = lang.color
<del> langs[lang.lang] = lang.color
<29>:<add> langs = list(langs
|
# module: backend.src.svg.top_repos
def get_top_repos_svg(
data: List[RepoStats], time_str: str, loc_metric: str, commits_excluded: int
) -> Drawing:
<0> subheader = time_str
<1> subheader += " | " + ("LOC Changed" if loc_metric == "changed" else "LOC Added")
<2> if commits_excluded > 50:
<3> subheader += " | " + str(commits_excluded) + " commits excluded"
<4>
<5> d, dp = get_template(
<6> width=300,
<7> height=285,
<8> padding=20,
<9> header_text="Most Contributed Repositories",
<10> subheader_text=subheader,
<11> debug=False,
<12> )
<13>
<14> dataset: List[Tuple[str, str, List[Tuple[float, str]]]] = []
<15> total = data[0].loc
<16> for x in data[:4]:
<17> data_row = []
<18> for lang in x.langs:
<19> data_row.append((100 * lang.loc / total, lang.color))
<20> name = "private/repository" if x.private else x.repo
<21> dataset.append((name, format_number(x.loc), data_row))
<22>
<23> dp.add(get_bar_section(d=d, dataset=dataset, padding=45, bar_width=195))
<24>
<25> langs = {}
<26> for x in data[:4]:
<27> for lang in x.langs:
<28> langs[lang.lang] = lang.color
<29> langs = list(langs.items())[:6]
<30>
<31> columns = {1: 1, 2: 2, 3: 3, 4: 2, 5: 3, 6: 3}[len(langs)]
<32> padding = 215 + (10 if columns == len(langs) else 0)
<33> dp.add(get_lang_name_section(d=d, data=langs, columns=columns, padding=padding))
<34>
<35> d.add(dp)
<36> return d</s>
|
===========unchanged ref 0===========
at: src.models.user.analytics.RepoLanguage
lang: str
color: str
loc: int
at: src.models.user.analytics.RepoStats
repo: str
private: bool
langs: List[RepoLanguage]
loc: int
at: src.svg.template
format_number(num: int) -> str
get_template(width: int, height: int, padding: int, header_text: str, subheader_text: str, debug: bool=False) -> Tuple[Drawing, Group]
get_bar_section(d: Drawing, dataset: List[Tuple[str, str, List[Tuple[float, str]]]], padding: int=45, bar_width: int=210) -> Group
get_lang_name_section(d: Drawing, data: List[Tuple[str, str]], columns: int=2, padding: int=80) -> Group
at: typing
Tuple = _TupleType(tuple, -1, inst=False, name='Tuple')
List = _alias(list, 1, inst=False, name='List')
|
backend.src.analytics.user.commits/get_top_languages
|
Modified
|
avgupta456~github-trends
|
00b6e777e6d9b0abbea9023c77fa276019f1fef9
|
backend bug fixes
|
<17>:<add> total_loc: int = sum(x["loc"] for x in languages_list) + 1 # type: ignore
<del> total_loc: int = sum(x["loc"] for x in languages_list) # type: ignore
<18>:<add> total: dict_type = {"lang": "Total", "loc": total_loc}
<del> total: dict_type = {"lang": "Total", "loc": total_loc + 1}
|
# module: backend.src.analytics.user.commits
def get_top_languages(
data: UserPackage, loc_metric: str, include_private: bool
) -> Tuple[List[LanguageStats], int]:
<0> raw_languages = (
<1> data.contribs.total_stats.languages
<2> if include_private
<3> else data.contribs.public_stats.languages
<4> )
<5>
<6> languages_list: List[dict_type] = [
<7> {
<8> "lang": lang,
<9> "color": stats.color,
<10> "loc": loc_metric_func(loc_metric, stats.additions, stats.deletions),
<11> }
<12> for lang, stats in raw_languages.items()
<13> ]
<14>
<15> languages_list = list(filter(lambda x: x["loc"] > 0, languages_list)) # type: ignore
<16>
<17> total_loc: int = sum(x["loc"] for x in languages_list) # type: ignore
<18> total: dict_type = {"lang": "Total", "loc": total_loc + 1}
<19>
<20> languages_list = sorted(languages_list, key=lambda x: x["loc"], reverse=True)
<21> other: dict_type = {"lang": "Other", "loc": 0, "color": "#ededed"}
<22> for language in languages_list[4:]:
<23> other["loc"] = int(other["loc"]) + int(language["loc"])
<24>
<25> languages_list = [total] + languages_list[:4] + [other]
<26>
<27> new_languages_list: List[LanguageStats] = []
<28> for lang in languages_list:
<29> lang["percent"] = float(round(100 * int(lang["loc"]) / total_loc, 2))
<30> if lang["percent"] > 1: # 1% minimum to show
<31> new_languages_list.append(LanguageStats.parse_obj(lang))
<32>
<33> commits_excluded = data.contribs.public_stats.other_count
<34> if include_private:
<35> </s>
|
===========below chunk 0===========
# module: backend.src.analytics.user.commits
def get_top_languages(
data: UserPackage, loc_metric: str, include_private: bool
) -> Tuple[List[LanguageStats], int]:
# offset: 1
return new_languages_list, commits_excluded
===========unchanged ref 0===========
at: backend.src.analytics.user.commits
dict_type = Dict[str, Union[str, int, float]]
loc_metric_func(loc_metric: str, additions: int, deletions: int) -> int
at: src.models.user.contribs.ContributionStats
contribs_count: int
commits_count: int
issues_count: int
prs_count: int
reviews_count: int
repos_count: int
other_count: int
languages: Dict[str, Language]
at: src.models.user.contribs.Language
color: str
additions: int
deletions: int
at: src.models.user.contribs.UserContributions
total_stats: ContributionStats
public_stats: ContributionStats
total: List[ContributionDay]
public: List[ContributionDay]
repo_stats: Dict[str, RepoContributionStats]
repos: Dict[str, List[ContributionDay]]
at: src.models.user.package.UserPackage
contribs: UserContributions
at: typing
Tuple = _TupleType(tuple, -1, inst=False, name='Tuple')
List = _alias(list, 1, inst=False, name='List')
===========changed ref 0===========
# module: backend.src.svg.top_repos
def get_top_repos_svg(
data: List[RepoStats], time_str: str, loc_metric: str, commits_excluded: int
) -> Drawing:
subheader = time_str
subheader += " | " + ("LOC Changed" if loc_metric == "changed" else "LOC Added")
if commits_excluded > 50:
subheader += " | " + str(commits_excluded) + " commits excluded"
d, dp = get_template(
width=300,
height=285,
padding=20,
header_text="Most Contributed Repositories",
subheader_text=subheader,
debug=False,
)
+ if len(data) > 0:
+ dataset: List[Tuple[str, str, List[Tuple[float, str]]]] = []
- dataset: List[Tuple[str, str, List[Tuple[float, str]]]] = []
+ total = data[0].loc
- total = data[0].loc
+ for x in data[:4]:
- for x in data[:4]:
+ data_row = []
- data_row = []
+ for lang in x.langs:
- for lang in x.langs:
+ data_row.append((100 * lang.loc / total, lang.color))
- data_row.append((100 * lang.loc / total, lang.color))
+ name = "private/repository" if x.private else x.repo
- name = "private/repository" if x.private else x.repo
+ dataset.append((name, format_number(x.loc), data_row))
- dataset.append((name, format_number(x.loc), data_row))
+ dp.add(get_bar_section(d=d, dataset=dataset, padding=45, bar_width=195))
- dp.add(get_bar_section(d=d, dataset=dataset, padding=45, bar_width=195))
+ langs = {}
- langs = {}</s>
===========changed ref 1===========
# module: backend.src.svg.top_repos
def get_top_repos_svg(
data: List[RepoStats], time_str: str, loc_metric: str, commits_excluded: int
) -> Drawing:
# offset: 1
<s>=d, dataset=dataset, padding=45, bar_width=195))
+ langs = {}
- langs = {}
+ for x in data[:4]:
- for x in data[:4]:
+ for lang in x.langs:
- for lang in x.langs:
+ langs[lang.lang] = lang.color
- langs[lang.lang] = lang.color
+ langs = list(langs.items())[:6]
- langs = list(langs.items())[:6]
+ columns = {1: 1, 2: 2, 3: 3, 4: 2, 5: 3, 6: 3}[len(langs)]
- columns = {1: 1, 2: 2, 3: 3, 4: 2, 5: 3, 6: 3}[len(langs)]
+ padding = 215 + (10 if columns == len(langs) else 0)
- padding = 215 + (10 if columns == len(langs) else 0)
+ dp.add(get_lang_name_section(d=d, data=langs, columns=columns, padding=padding))
- dp.add(get_lang_name_section(d=d, data=langs, columns=columns, padding=padding))
d.add(dp)
+
return d
|
backend.src.svg.top_repos/get_top_repos_svg
|
Modified
|
avgupta456~github-trends
|
a8e0eab84eb9a5eccc0961933b783c31cca27759
|
no data svg
|
<0>:<add> header = "Most Contributed Repositories"
<5>:<add> if len(data) == 0:
<add> return get_no_data_svg(header, subheader)
<add>
<9>:<add> header_text=header,
<del> header_text="Most Contributed Repositories",
<14>:<del> if len(data) > 0:
<15>:<add> dataset: List[Tuple[str, str, List[Tuple[float, str]]]] = []
<del> dataset: List[Tuple[str, str, List[Tuple[float, str]]]] = []
<16>:<add> total = data[0].loc
<del> total = data[0].loc
<17>:<add> for x in data[:4]:
<del> for x in data[:4]:
<18>:<add> data_row = []
<del> data_row = []
<19>:<add> for lang in x.langs:
<del> for lang in x.langs:
<20>:<add> data_row.append((100 * lang.loc / total, lang.color))
<del> data_row.append((100 * lang.loc / total, lang.color))
<21>:<add> name = "private/repository" if x.private else x.repo
<del> name = "private/repository" if x.private else x.repo
<22>:<add> dataset.append((name, format_number(x.loc), data_row))
<del> dataset.append((name, format_number(x.loc), data_row))
<24>:<add> dp.add(get_bar_section(d=d, dataset=dataset, padding=45, bar_width=195))
<del> dp.add(get_bar_section(d=d, dataset=dataset, padding=45, bar_width=195))
<26>:<add> langs = {}
<del> langs = {}
<27>:<add> for x in data
|
# module: backend.src.svg.top_repos
def get_top_repos_svg(
data: List[RepoStats], time_str: str, loc_metric: str, commits_excluded: int
) -> Drawing:
<0> subheader = time_str
<1> subheader += " | " + ("LOC Changed" if loc_metric == "changed" else "LOC Added")
<2> if commits_excluded > 50:
<3> subheader += " | " + str(commits_excluded) + " commits excluded"
<4>
<5> d, dp = get_template(
<6> width=300,
<7> height=285,
<8> padding=20,
<9> header_text="Most Contributed Repositories",
<10> subheader_text=subheader,
<11> debug=False,
<12> )
<13>
<14> if len(data) > 0:
<15> dataset: List[Tuple[str, str, List[Tuple[float, str]]]] = []
<16> total = data[0].loc
<17> for x in data[:4]:
<18> data_row = []
<19> for lang in x.langs:
<20> data_row.append((100 * lang.loc / total, lang.color))
<21> name = "private/repository" if x.private else x.repo
<22> dataset.append((name, format_number(x.loc), data_row))
<23>
<24> dp.add(get_bar_section(d=d, dataset=dataset, padding=45, bar_width=195))
<25>
<26> langs = {}
<27> for x in data[:4]:
<28> for lang in x.langs:
<29> langs[lang.lang] = lang.color
<30> langs = list(langs.items())[:6]
<31>
<32> columns = {1: 1, 2: 2, 3: 3, 4: 2, 5: 3, 6: 3}[len(langs)]
<33> padding = 215 + (10 if columns == len(langs) else 0)
<34> dp.add(get_lang_name_section(d=d, data=langs, columns=columns, padding=padding))
<35>
<36> </s>
|
===========below chunk 0===========
# module: backend.src.svg.top_repos
def get_top_repos_svg(
data: List[RepoStats], time_str: str, loc_metric: str, commits_excluded: int
) -> Drawing:
# offset: 1
return d
===========unchanged ref 0===========
at: src.models.user.analytics.RepoLanguage
lang: str
color: str
loc: int
at: src.models.user.analytics.RepoStats
repo: str
private: bool
langs: List[RepoLanguage]
loc: int
at: src.svg.error
get_no_data_svg(header: str, subheader: str) -> Drawing
at: src.svg.template
format_number(num: int) -> str
get_template(width: int, height: int, padding: int, header_text: str, subheader_text: str, debug: bool=False) -> Tuple[Drawing, Group]
get_bar_section(d: Drawing, dataset: List[Tuple[str, str, List[Tuple[float, str]]]], padding: int=45, bar_width: int=210) -> Group
get_lang_name_section(d: Drawing, data: List[Tuple[str, str]], columns: int=2, padding: int=80) -> Group
at: typing
Tuple = _TupleType(tuple, -1, inst=False, name='Tuple')
List = _alias(list, 1, inst=False, name='List')
|
backend.src.svg.top_langs/get_top_langs_svg
|
Modified
|
avgupta456~github-trends
|
a8e0eab84eb9a5eccc0961933b783c31cca27759
|
no data svg
|
<0>:<add> header = "Most Used Languages"
<6>:<add> if len(data) <= 1:
<add> return get_no_data_svg(header, subheader)
<add>
<10>:<add> header_text=header,
<del> header_text="Most Used Languages",
|
# module: backend.src.svg.top_langs
def get_top_langs_svg(
data: List[LanguageStats],
time_str: str,
use_percent: bool,
loc_metric: str,
commits_excluded: int,
compact: bool,
) -> Drawing:
<0> subheader = time_str
<1> if not use_percent:
<2> subheader += " | " + ("LOC Changed" if loc_metric == "changed" else "LOC Added")
<3> if commits_excluded > 50:
<4> subheader += " | " + str(commits_excluded) + " commits excluded"
<5>
<6> d, dp = get_template(
<7> width=300,
<8> height=175 if compact else 285,
<9> padding=20,
<10> header_text="Most Used Languages",
<11> subheader_text=subheader,
<12> debug=False,
<13> )
<14>
<15> dataset: List[Tuple[str, str, List[Tuple[float, str]]]] = []
<16> padding, width = 0, 0
<17> if compact:
<18> data_row = []
<19> for x in data[1:6]:
<20> data_row.append((x.percent, x.color))
<21> dataset.append(("", "", data_row))
<22> padding, width = 30, 260
<23> else:
<24> for x in data[1:6]:
<25> if use_percent:
<26> dataset.append((x.lang, str(x.percent) + "%", [(x.percent, x.color)]))
<27> else:
<28> percent = 100 * x.loc / data[1].loc
<29> dataset.append((x.lang, format_number(x.loc), [(percent, x.color)]))
<30> padding, width = 45, 210 if use_percent else 195
<31>
<32> dp.add(get_bar_section(d=d, dataset=dataset, padding=padding, bar_width=width))
<33>
<34> langs = [(x.lang + " " + str(x.percent) + "%",</s>
|
===========below chunk 0===========
# module: backend.src.svg.top_langs
def get_top_langs_svg(
data: List[LanguageStats],
time_str: str,
use_percent: bool,
loc_metric: str,
commits_excluded: int,
compact: bool,
) -> Drawing:
# offset: 1
if compact:
dp.add(get_lang_name_section(d=d, data=langs))
d.add(dp)
return d
===========unchanged ref 0===========
at: src.models.user.analytics.LanguageStats
lang: str
loc: int
percent: float
color: Optional[str]
at: src.svg.error
get_no_data_svg(header: str, subheader: str) -> Drawing
at: src.svg.template
format_number(num: int) -> str
get_template(width: int, height: int, padding: int, header_text: str, subheader_text: str, debug: bool=False) -> Tuple[Drawing, Group]
get_bar_section(d: Drawing, dataset: List[Tuple[str, str, List[Tuple[float, str]]]], padding: int=45, bar_width: int=210) -> Group
at: typing
Tuple = _TupleType(tuple, -1, inst=False, name='Tuple')
List = _alias(list, 1, inst=False, name='List')
===========changed ref 0===========
# module: backend.src.svg.error
+ def get_no_data_svg(header: str, subheader: str) -> Drawing:
+ d, dp = get_template(
+ width=300,
+ height=285,
+ padding=20,
+ header_text=header,
+ subheader_text=subheader,
+ debug=False,
+ )
+
+ d.add(d.image(BACKEND_URL + "/assets/error", insert=(85, 80), style="opacity: 50%"))
+ dp.add(d.text("No data to show", insert=(42, 220), class_="no-data"))
+
+ d.add(dp)
+ return d
+
===========changed ref 1===========
# module: backend.src.svg.style
style = """
.header {
font: 600 18px 'Segoe UI', Ubuntu, Sans-Serif;
fill: #2f80ed;
animation: fadeInAnimation 0.8s ease-in-out forwards;
}
.subheader {
font: 500 10px 'Segoe UI', Ubuntu, San-Serif;
fill: #666;
animation: fadeInAnimation 0.8s ease-in-out forwards;
}
.lang-name {
font: 400 11px 'Segoe UI', Ubuntu, Sans-Serif;
fill: #333;
}
+ .no-data {
+ font: 400 24px 'Segoe UI', Ubuntu, Sans-Serif;
+ fill: #777;
+ }
@keyframes fadeInAnimation {
from {
opacity: 0;
}
to {
opacity: 1;
}
}
"""
===========changed ref 2===========
# module: backend.src.svg.top_repos
def get_top_repos_svg(
data: List[RepoStats], time_str: str, loc_metric: str, commits_excluded: int
) -> Drawing:
+ header = "Most Contributed Repositories"
subheader = time_str
subheader += " | " + ("LOC Changed" if loc_metric == "changed" else "LOC Added")
if commits_excluded > 50:
subheader += " | " + str(commits_excluded) + " commits excluded"
+ if len(data) == 0:
+ return get_no_data_svg(header, subheader)
+
d, dp = get_template(
width=300,
height=285,
padding=20,
+ header_text=header,
- header_text="Most Contributed Repositories",
subheader_text=subheader,
debug=False,
)
- if len(data) > 0:
+ dataset: List[Tuple[str, str, List[Tuple[float, str]]]] = []
- dataset: List[Tuple[str, str, List[Tuple[float, str]]]] = []
+ total = data[0].loc
- total = data[0].loc
+ for x in data[:4]:
- for x in data[:4]:
+ data_row = []
- data_row = []
+ for lang in x.langs:
- for lang in x.langs:
+ data_row.append((100 * lang.loc / total, lang.color))
- data_row.append((100 * lang.loc / total, lang.color))
+ name = "private/repository" if x.private else x.repo
- name = "private/repository" if x.private else x.repo
+ dataset.append((name, format_number(x.loc), data_row))
- dataset.append((name, format_number(x.loc), data_row))
+ dp.add(get_bar_section(d=d, dataset=dataset, padding=45</s>
===========changed ref 3===========
# module: backend.src.svg.top_repos
def get_top_repos_svg(
data: List[RepoStats], time_str: str, loc_metric: str, commits_excluded: int
) -> Drawing:
# offset: 1
<s>), data_row))
+ dp.add(get_bar_section(d=d, dataset=dataset, padding=45, bar_width=195))
- dp.add(get_bar_section(d=d, dataset=dataset, padding=45, bar_width=195))
+ langs = {}
- langs = {}
+ for x in data[:4]:
- for x in data[:4]:
+ for lang in x.langs:
- for lang in x.langs:
+ langs[lang.lang] = lang.color
- langs[lang.lang] = lang.color
+ langs = list(langs.items())[:6]
- langs = list(langs.items())[:6]
+ columns = {1: 1, 2: 2, 3: 3, 4: 2, 5: 3, 6: 3}[len(langs)]
- columns = {1: 1, 2: 2, 3: 3, 4: 2, 5: 3, 6: 3}[len(langs)]
+ padding = 215 + (10 if columns == len(langs) else 0)
- padding = 215 + (10 if columns == len(langs) else 0)
+ dp.add(get_lang_name_section(d=d, data=langs, columns=columns, padding=padding))
- dp.add(get_lang_name_section(d=d, data=langs, columns=columns, padding=padding))
d.add(dp)
-
return d
|
backend.src.svg.error/get_no_data_svg
|
Modified
|
avgupta456~github-trends
|
25fc6429579c926d6eae2b7a742497702d35ae04
|
improve demo ui
|
<10>:<add> dp.add(d.text("No data to show", insert=(55, 220), class_="no-data"))
<del> dp.add(d.text("No data to show", insert=(42, 220), class_="no-data"))
|
# module: backend.src.svg.error
def get_no_data_svg(header: str, subheader: str) -> Drawing:
<0> d, dp = get_template(
<1> width=300,
<2> height=285,
<3> padding=20,
<4> header_text=header,
<5> subheader_text=subheader,
<6> debug=False,
<7> )
<8>
<9> d.add(d.image(BACKEND_URL + "/assets/error", insert=(85, 80), style="opacity: 50%"))
<10> dp.add(d.text("No data to show", insert=(42, 220), class_="no-data"))
<11>
<12> d.add(dp)
<13> return d
<14>
|
===========unchanged ref 0===========
at: src.constants
BACKEND_URL = "https://api.githubtrends.io" if PROD else "http://localhost:8000"
at: src.svg.template
get_template(width: int, height: int, padding: int, header_text: str, subheader_text: str, debug: bool=False) -> Tuple[Drawing, Group]
|
backend.src.analytics.user.commits/get_top_languages
|
Modified
|
avgupta456~github-trends
|
de616a8b93cd208b3e434cee7d13a41a4626c843
|
misc backend fixes
|
<9>:<add> "color": stats.color or DEFAULT_COLOR,
<del> "color": stats.color,
|
# module: backend.src.analytics.user.commits
def get_top_languages(
data: UserPackage, loc_metric: str, include_private: bool
) -> Tuple[List[LanguageStats], int]:
<0> raw_languages = (
<1> data.contribs.total_stats.languages
<2> if include_private
<3> else data.contribs.public_stats.languages
<4> )
<5>
<6> languages_list: List[dict_type] = [
<7> {
<8> "lang": lang,
<9> "color": stats.color,
<10> "loc": loc_metric_func(loc_metric, stats.additions, stats.deletions),
<11> }
<12> for lang, stats in raw_languages.items()
<13> ]
<14>
<15> languages_list = list(filter(lambda x: x["loc"] > 0, languages_list)) # type: ignore
<16>
<17> total_loc: int = sum(x["loc"] for x in languages_list) + 1 # type: ignore
<18> total: dict_type = {"lang": "Total", "loc": total_loc}
<19>
<20> languages_list = sorted(languages_list, key=lambda x: x["loc"], reverse=True)
<21> other: dict_type = {"lang": "Other", "loc": 0, "color": "#ededed"}
<22> for language in languages_list[4:]:
<23> other["loc"] = int(other["loc"]) + int(language["loc"])
<24>
<25> languages_list = [total] + languages_list[:4] + [other]
<26>
<27> new_languages_list: List[LanguageStats] = []
<28> for lang in languages_list:
<29> lang["percent"] = float(round(100 * int(lang["loc"]) / total_loc, 2))
<30> if lang["percent"] > 1: # 1% minimum to show
<31> new_languages_list.append(LanguageStats.parse_obj(lang))
<32>
<33> commits_excluded = data.contribs.public_stats.other_count
<34> if include_private:
<35> </s>
|
===========below chunk 0===========
# module: backend.src.analytics.user.commits
def get_top_languages(
data: UserPackage, loc_metric: str, include_private: bool
) -> Tuple[List[LanguageStats], int]:
# offset: 1
return new_languages_list, commits_excluded
===========unchanged ref 0===========
at: backend.src.analytics.user.commits
dict_type = Dict[str, Union[str, int, float]]
loc_metric_func(loc_metric: str, additions: int, deletions: int) -> int
at: src.constants
DEFAULT_COLOR = "#858585"
at: src.models.user.contribs.ContributionStats
contribs_count: int
commits_count: int
issues_count: int
prs_count: int
reviews_count: int
repos_count: int
other_count: int
languages: Dict[str, Language]
at: src.models.user.contribs.Language
color: str
additions: int
deletions: int
at: src.models.user.contribs.UserContributions
total_stats: ContributionStats
public_stats: ContributionStats
total: List[ContributionDay]
public: List[ContributionDay]
repo_stats: Dict[str, RepoContributionStats]
repos: Dict[str, List[ContributionDay]]
at: src.models.user.package.UserPackage
contribs: UserContributions
at: typing
Tuple = _TupleType(tuple, -1, inst=False, name='Tuple')
List = _alias(list, 1, inst=False, name='List')
===========changed ref 0===========
# module: backend.src.svg.template
-
-
===========changed ref 1===========
# module: backend.src.svg.template
- DEFAULT_COLOR = "#858585"
-
|
backend.src.routers.users.svg/svg_base
|
Modified
|
avgupta456~github-trends
|
de616a8b93cd208b3e434cee7d13a41a4626c843
|
misc backend fixes
|
<6>:<add> output = await get_user_demo(user_id, start_date, end_date)
<del> output = await get_user_demo(user_id)
|
# module: backend.src.routers.users.svg
def svg_base(
user_id: str, start_date: date, end_date: date, time_range: str, demo: bool
) -> Tuple[Optional[UserPackage], str]:
<0> # process time_range, start_date, end_date
<1> time_range = "one_month" if demo else time_range
<2> start_date, end_date, time_str = use_time_range(time_range, start_date, end_date)
<3>
<4> # fetch data, either using demo or user method
<5> if demo:
<6> output = await get_user_demo(user_id)
<7> else:
<8> output = await get_user(user_id, start_date, end_date)
<9>
<10> return output, time_str
<11>
|
===========unchanged ref 0===========
at: datetime
date()
at: src.helper.utils
use_time_range(time_range: str, start_date: date, end_date: date) -> Tuple[date, date, str]
at: src.routers.users.get_data
Callable(*args: List[Any], **kwargs: Dict[str, Any]) -> Any
Callable(*args: List[Any], **kwargs: Dict[str, Any]) -> Any
at: typing
Tuple = _TupleType(tuple, -1, inst=False, name='Tuple')
===========changed ref 0===========
# module: backend.src.svg.template
-
-
===========changed ref 1===========
# module: backend.src.svg.template
- DEFAULT_COLOR = "#858585"
-
===========changed ref 2===========
# module: backend.src.models.user.analytics
class RepoLanguage(BaseModel):
lang: str
+ color: Optional[str]
- color: str
loc: int
===========changed ref 3===========
# module: backend.src.analytics.user.commits
def get_top_languages(
data: UserPackage, loc_metric: str, include_private: bool
) -> Tuple[List[LanguageStats], int]:
raw_languages = (
data.contribs.total_stats.languages
if include_private
else data.contribs.public_stats.languages
)
languages_list: List[dict_type] = [
{
"lang": lang,
+ "color": stats.color or DEFAULT_COLOR,
- "color": stats.color,
"loc": loc_metric_func(loc_metric, stats.additions, stats.deletions),
}
for lang, stats in raw_languages.items()
]
languages_list = list(filter(lambda x: x["loc"] > 0, languages_list)) # type: ignore
total_loc: int = sum(x["loc"] for x in languages_list) + 1 # type: ignore
total: dict_type = {"lang": "Total", "loc": total_loc}
languages_list = sorted(languages_list, key=lambda x: x["loc"], reverse=True)
other: dict_type = {"lang": "Other", "loc": 0, "color": "#ededed"}
for language in languages_list[4:]:
other["loc"] = int(other["loc"]) + int(language["loc"])
languages_list = [total] + languages_list[:4] + [other]
new_languages_list: List[LanguageStats] = []
for lang in languages_list:
lang["percent"] = float(round(100 * int(lang["loc"]) / total_loc, 2))
if lang["percent"] > 1: # 1% minimum to show
new_languages_list.append(LanguageStats.parse_obj(lang))
commits_excluded = data.contribs.public_stats.other_count
if include_private:
commits_excluded = data.contribs.total_stats.other_count
return new</s>
===========changed ref 4===========
# module: backend.src.analytics.user.commits
def get_top_languages(
data: UserPackage, loc_metric: str, include_private: bool
) -> Tuple[List[LanguageStats], int]:
# offset: 1
<s>
if include_private:
commits_excluded = data.contribs.total_stats.other_count
return new_languages_list, commits_excluded
|
backend.src.routers.users.get_data/get_user_demo
|
Modified
|
avgupta456~github-trends
|
de616a8b93cd208b3e434cee7d13a41a4626c843
|
misc backend fixes
|
<1>:<del> start_date, end_date, _ = use_time_range("one_month", date.today(), date.today())
|
# module: backend.src.routers.users.get_data
@alru_cache()
+ async def get_user_demo(user_id: str, start_date: date, end_date: date) -> UserPackage:
- async def get_user_demo(user_id: str) -> UserPackage:
<0> access_token = await get_next_key("demo")
<1> start_date, end_date, _ = use_time_range("one_month", date.today(), date.today())
<2> data = await get_data(user_id, access_token, start_date, end_date)
<3> return (True, data) # type: ignore
<4>
|
===========unchanged ref 0===========
at: datetime
date()
at: src.db.secret.functions
get_next_key(project: str) -> str
at: src.packaging.user
main(user_id: str, access_token: str, start_date: date, end_date: date, timezone_str: str="US/Eastern") -> UserPackage
===========changed ref 0===========
# module: backend.src.svg.template
-
-
===========changed ref 1===========
# module: backend.src.svg.template
- DEFAULT_COLOR = "#858585"
-
===========changed ref 2===========
# module: backend.src.models.user.contribs
class Language(BaseModel):
+ color: Optional[str]
- color: str
additions: int
deletions: int
===========changed ref 3===========
# module: backend.src.models.user.analytics
class RepoLanguage(BaseModel):
lang: str
+ color: Optional[str]
- color: str
loc: int
===========changed ref 4===========
# module: backend.src.routers.users.svg
def svg_base(
user_id: str, start_date: date, end_date: date, time_range: str, demo: bool
) -> Tuple[Optional[UserPackage], str]:
# process time_range, start_date, end_date
time_range = "one_month" if demo else time_range
start_date, end_date, time_str = use_time_range(time_range, start_date, end_date)
# fetch data, either using demo or user method
if demo:
+ output = await get_user_demo(user_id, start_date, end_date)
- output = await get_user_demo(user_id)
else:
output = await get_user(user_id, start_date, end_date)
return output, time_str
===========changed ref 5===========
# module: backend.src.analytics.user.commits
def get_top_languages(
data: UserPackage, loc_metric: str, include_private: bool
) -> Tuple[List[LanguageStats], int]:
raw_languages = (
data.contribs.total_stats.languages
if include_private
else data.contribs.public_stats.languages
)
languages_list: List[dict_type] = [
{
"lang": lang,
+ "color": stats.color or DEFAULT_COLOR,
- "color": stats.color,
"loc": loc_metric_func(loc_metric, stats.additions, stats.deletions),
}
for lang, stats in raw_languages.items()
]
languages_list = list(filter(lambda x: x["loc"] > 0, languages_list)) # type: ignore
total_loc: int = sum(x["loc"] for x in languages_list) + 1 # type: ignore
total: dict_type = {"lang": "Total", "loc": total_loc}
languages_list = sorted(languages_list, key=lambda x: x["loc"], reverse=True)
other: dict_type = {"lang": "Other", "loc": 0, "color": "#ededed"}
for language in languages_list[4:]:
other["loc"] = int(other["loc"]) + int(language["loc"])
languages_list = [total] + languages_list[:4] + [other]
new_languages_list: List[LanguageStats] = []
for lang in languages_list:
lang["percent"] = float(round(100 * int(lang["loc"]) / total_loc, 2))
if lang["percent"] > 1: # 1% minimum to show
new_languages_list.append(LanguageStats.parse_obj(lang))
commits_excluded = data.contribs.public_stats.other_count
if include_private:
commits_excluded = data.contribs.total_stats.other_count
return new</s>
===========changed ref 6===========
# module: backend.src.analytics.user.commits
def get_top_languages(
data: UserPackage, loc_metric: str, include_private: bool
) -> Tuple[List[LanguageStats], int]:
# offset: 1
<s>
if include_private:
commits_excluded = data.contribs.total_stats.other_count
return new_languages_list, commits_excluded
===========changed ref 7===========
# module: backend.src.constants
# GLOBAL
PROD = os.getenv("PROD", "False") == "True"
DOCKER = os.getenv("DOCKER", "False") == "True"
PROJECT_ID = "github-298920"
BACKEND_URL = "https://api.githubtrends.io" if PROD else "http://localhost:8000"
# API
# https://docs.github.com/en/rest/reference/rate-limit
# https://docs.github.com/en/rest/guides/best-practices-for-integrators#dealing-with-secondary-rate-limits
# https://docs.github.com/en/graphql/overview/resource-limitations
TIMEOUT = 10 # max seconds to wait for api response
NODE_CHUNK_SIZE = 100 # number of nodes (commits) to query (max 100)
NODE_THREADS = 10 # number of node queries simultaneously (avoid blacklisting)
CUTOFF = 500 # if > cutoff lines, assume imported, don't count
# CUSTOMIZATION
BLACKLIST = ["Jupyter Notebook", "HTML"] # languages to ignore
# OAUTH
OAUTH_CLIENT_ID = os.getenv("OAUTH_CLIENT_ID", "") # client ID for GitHub OAuth App
OAUTH_CLIENT_SECRET = os.getenv("OAUTH_CLIENT_SECRET", "") # client secret for App
OAUTH_REDIRECT_URI = os.getenv("OAUTH_REDIRECT_URI", "") # redirect uri for App
# PUBSUB
PUBSUB_PUB = os.getenv("PUBSUB_PUB", "False") == "True"
PUBSUB_TOKEN = os.getenv("PUBSUB_TOKEN", "")
LOCAL_SUBSCRIBER = ( # based on name of Docker container
"http://" + ("subscriber" if DOCKER else "localhost") + ":8001/pubsub/sub/"
)
# MONGODB
MONGODB_PASSWORD = os.getenv("MONGODB_PASSWORD", "")
+ # SVG
+ DEFAULT_COLOR = "#858585"
+
# SENTRY
SENTRY_DSN</s>
===========changed ref 8===========
# module: backend.src.constants
# offset: 1
<s> "")
+ # SVG
+ DEFAULT_COLOR = "#858585"
+
# SENTRY
SENTRY_DSN = os.getenv("SENTRY_DSN", "")
# TESTING
TEST_USER_ID = "AshishGupta938" # for testing, previously "avgupta456"
TEST_TOKEN = os.getenv("AUTH_TOKEN", "") # for authentication
|
backend.src.routers.users.get_data/_get_user
|
Modified
|
avgupta456~github-trends
|
ae4249c284fc3da0c7114b485f31aa781eecc7c2
|
Merge branch 'main' of https://github.com/avgupta456/github-trends
|
<3>:<add> db_user: Optional[UserModel] = await get_user_by_user_id(user_id)
<del> db_user = await get_user_by_user_id(user_id)
<7>:<add> last_updated: datetime = datetime(1970, 1, 1)
<add> if db_user.last_updated is not None:
<add> last_updated = db_user.last_updated
<add>
<add> time_diff = datetime.now() - last_updated
<del> time_diff = datetime.now() - db_user.last_updated
<9>:<add> if db_user.lock is None or not db_user.lock:
<del> if not db_user.lock:
|
# module: backend.src.routers.users.get_data
def _get_user(user_id: str) -> Optional[UserPackage]:
<0> if not PUBSUB_PUB:
<1> raise HTTPException(400, "")
<2>
<3> db_user = await get_user_by_user_id(user_id)
<4> if db_user is None or db_user.access_token == "":
<5> raise LookupError("Invalid UserId")
<6>
<7> time_diff = datetime.now() - db_user.last_updated
<8> if time_diff > timedelta(hours=6) or not validate_raw_data(db_user.raw_data):
<9> if not db_user.lock:
<10> publish_to_topic(
<11> "user", {"user_id": user_id, "access_token": db_user.access_token}
<12> )
<13>
<14> if validate_raw_data(db_user.raw_data):
<15> return db_user.raw_data # type: ignore
<16>
<17> return None
<18>
|
===========unchanged ref 0===========
at: backend.src.routers.users.get_data
validate_raw_data(data: Optional[UserPackage]) -> bool
at: datetime
timedelta(days: float=..., seconds: float=..., microseconds: float=..., milliseconds: float=..., minutes: float=..., hours: float=..., weeks: float=..., *, fold: int=...)
datetime()
at: datetime.datetime
__slots__ = date.__slots__ + time.__slots__
now(tz: Optional[_tzinfo]=...) -> _S
__radd__ = __add__
at: src.constants
PUBSUB_PUB = os.getenv("PUBSUB_PUB", "False") == "True"
at: src.db.user.get
Callable(*args: List[Any], **kwargs: Dict[str, Any]) -> Any
at: src.db.user.models.UserModel
user_id: str
access_token: str
last_updated: Optional[datetime]
raw_data: Optional[UserPackage]
lock: Optional[bool]
at: src.external.pubsub.templates
publish_to_topic(topic: str, message: Dict[str, Any]) -> None
|
backend.src.helper.alru_cache/alru_cache
|
Modified
|
avgupta456~github-trends
|
81a8ba978bae92863146c904aebfeba099bd01fc
|
Update alru_cache.py
|
<4>:<add> def in_cache(key: Any) -> bool:
<add> # key not in cache
<add> if key not in cache:
<add> return False
<add>
<add> # key in cache but expired
<add> if datetime.now() - cache[key][0] > ttl:
<add> return False
<add>
<add> # key in cache and not expired
<add> return True
<add>
<add> def update_cache_and_return(key: Any, flag: bool, value: Any) -> Any:
<add> # if flag = False, do not update cache and return value
<add> if not flag:
<add> return value
<add>
<add> # if flag = True, update cache
<add> now = datetime.now()
<add> cache[key] = (now, value)
<add> keys.append(key)
<add>
<add> # remove oldest key if cache is full
<add> if len(keys) > max_size:
<add> del cache[keys.pop(0)]
<add>
<add> # return value from cache
<add> return cache[key][1]
<add>
|
# module: backend.src.helper.alru_cache
+ # NOTE: return flag = False to avoid caching
- # NOTE: return None to avoid caching
+ # considers two optional parameters
+ # if ignore_cache=True provided, bypass cache system and do not save to cache
+ # if ignore_cache=True and update_cache=True, bypass cache and save result to cache
+ # otherwise, use cache normally
def alru_cache(max_size: int = 128, ttl: timedelta = timedelta(minutes=5)):
<0> def decorator(func: Callable[..., Any]) -> Any:
<1> cache: Dict[Any, Tuple[datetime, Any]] = {}
<2> keys: List[Any] = []
<3>
<4> @wraps(func)
<5> async def wrapper(*args: List[Any], **kwargs: Dict[str, Any]) -> Any:
<6> if "use_cache" in kwargs and kwargs["use_cache"] is False:
<7> (flag, value) = await func(*args, **kwargs)
<8> return value
<9> now = datetime.now()
<10> key = tuple(args), frozenset(kwargs.items())
<11> if key not in cache or now - cache[key][0] > ttl:
<12> (flag, value) = await func(*args, **kwargs)
<13> if not flag:
<14> return value
<15> cache[key] = (now, value)
<16> keys.append(key)
<17> if len(keys) > max_size:
<18> del cache[keys.pop(0)]
<19> return cache[key][1]
<20>
<21> return wrapper
<22>
<23> return decorator
<24>
|
===========unchanged ref 0===========
at: datetime
timedelta(days: float=..., seconds: float=..., microseconds: float=..., milliseconds: float=..., minutes: float=..., hours: float=..., weeks: float=..., *, fold: int=...)
datetime()
at: datetime.datetime
__slots__ = date.__slots__ + time.__slots__
now(tz: Optional[_tzinfo]=...) -> _S
__radd__ = __add__
at: typing
Callable = _CallableType(collections.abc.Callable, 2)
Tuple = _TupleType(tuple, -1, inst=False, name='Tuple')
List = _alias(list, 1, inst=False, name='List')
Dict = _alias(dict, 2, inst=False, name='Dict')
|
backend.src.db.secret.functions/get_next_key
|
Modified
|
avgupta456~github-trends
|
0e36c7255808cc3b687d276bda3a2c2c999c4744
|
overwrite demo caching
|
<0>:<add> keys: List[str] = await get_keys(
<del> keys: List[str] = await get_keys(project)
<1>:<add> project, ignore_cache=override_cache, update_cache=override_cache
<add> )
|
# module: backend.src.db.secret.functions
+ def get_next_key(project: str, override_cache: bool = False) -> str:
- def get_next_key(project: str) -> str:
<0> keys: List[str] = await get_keys(project)
<1> if len(keys) == 0:
<2> return ""
<3>
<4> return keys[randint(0, len(keys) - 1)]
<5>
|
===========unchanged ref 0===========
at: backend.src.db.secret.functions
Callable(*args: List[Any], **kwargs: Dict[str, Any]) -> Any
at: typing
List = _alias(list, 1, inst=False, name='List')
|
backend.src.routers.users.svg/svg_base
|
Modified
|
avgupta456~github-trends
|
0e36c7255808cc3b687d276bda3a2c2c999c4744
|
overwrite demo caching
|
<6>:<add> output = await get_user_demo(
<add> user_id, start_date, end_date, ignore_cache=no_cache, update_cache=no_cache
<add> )
<del> output = await get_user_demo(user_id, start_date, end_date)
|
# module: backend.src.routers.users.svg
def svg_base(
+ user_id: str,
+ start_date: date,
+ end_date: date,
+ time_range: str,
+ demo: bool,
+ no_cache: bool = False,
- user_id: str, start_date: date, end_date: date, time_range: str, demo: bool
) -> Tuple[Optional[UserPackage], str]:
<0> # process time_range, start_date, end_date
<1> time_range = "one_month" if demo else time_range
<2> start_date, end_date, time_str = use_time_range(time_range, start_date, end_date)
<3>
<4> # fetch data, either using demo or user method
<5> if demo:
<6> output = await get_user_demo(user_id, start_date, end_date)
<7> else:
<8> output = await get_user(user_id, start_date, end_date)
<9>
<10> return output, time_str
<11>
|
===========unchanged ref 0===========
at: datetime
date()
at: src.helper.utils
use_time_range(time_range: str, start_date: date, end_date: date) -> Tuple[date, date, str]
at: typing
Tuple = _TupleType(tuple, -1, inst=False, name='Tuple')
===========changed ref 0===========
# module: backend.src.db.secret.functions
+ def get_next_key(project: str, override_cache: bool = False) -> str:
- def get_next_key(project: str) -> str:
+ keys: List[str] = await get_keys(
- keys: List[str] = await get_keys(project)
+ project, ignore_cache=override_cache, update_cache=override_cache
+ )
if len(keys) == 0:
return ""
return keys[randint(0, len(keys) - 1)]
|
backend.src.routers.users.svg/get_user_lang_svg
|
Modified
|
avgupta456~github-trends
|
0e36c7255808cc3b687d276bda3a2c2c999c4744
|
overwrite demo caching
|
<0>:<add> output, time_str = await svg_base(
<add> user_id, start_date, end_date, time_range, demo, no_cache
<add> )
<del> output, time_str = await svg_base(user_id, start_date, end_date, time_range, demo)
|
<s> user_id: str,
start_date: date = date.today() - timedelta(30),
end_date: date = date.today(),
time_range: str = "one_year",
timezone_str: str = "US/Eastern",
use_percent: bool = False,
include_private: bool = False,
loc_metric: str = "added",
compact: bool = False,
demo: bool = False,
+ no_cache: bool = False,
) -> Any:
<0> output, time_str = await svg_base(user_id, start_date, end_date, time_range, demo)
<1>
<2> # if no data, return loading svg
<3> if output is None:
<4> return get_loading_svg()
<5>
<6> # get top languages
<7> processed, num_excluded = get_top_languages(output, loc_metric, include_private)
<8> return get_top_langs_svg(
<9> processed, time_str, use_percent, loc_metric, num_excluded, compact
<10> )
<11>
|
===========unchanged ref 0===========
at: backend.src.routers.users.svg
router = APIRouter()
svg_base(user_id: str, start_date: date, end_date: date, time_range: str, demo: bool, no_cache: bool=False) -> Tuple[Optional[UserPackage], str]
at: backend.src.routers.users.svg.svg_base
start_date, end_date, time_str = use_time_range(time_range, start_date, end_date)
start_date, end_date, time_str = use_time_range(time_range, start_date, end_date)
start_date, end_date, time_str = use_time_range(time_range, start_date, end_date)
at: datetime
timedelta(days: float=..., seconds: float=..., microseconds: float=..., milliseconds: float=..., minutes: float=..., hours: float=..., weeks: float=..., *, fold: int=...)
date()
at: datetime.date
__slots__ = '_year', '_month', '_day', '_hashcode'
today() -> _S
__str__ = isoformat
__radd__ = __add__
at: src.helper.decorators
svg_fail_gracefully(func: Callable[..., Any])
at: src.routers.users.get_data
Callable(*args: List[Any], **kwargs: Dict[str, Any]) -> Any
===========changed ref 0===========
# module: backend.src.routers.users.svg
def svg_base(
+ user_id: str,
+ start_date: date,
+ end_date: date,
+ time_range: str,
+ demo: bool,
+ no_cache: bool = False,
- user_id: str, start_date: date, end_date: date, time_range: str, demo: bool
) -> Tuple[Optional[UserPackage], str]:
# process time_range, start_date, end_date
time_range = "one_month" if demo else time_range
start_date, end_date, time_str = use_time_range(time_range, start_date, end_date)
# fetch data, either using demo or user method
if demo:
+ output = await get_user_demo(
+ user_id, start_date, end_date, ignore_cache=no_cache, update_cache=no_cache
+ )
- output = await get_user_demo(user_id, start_date, end_date)
else:
output = await get_user(user_id, start_date, end_date)
return output, time_str
===========changed ref 1===========
# module: backend.src.db.secret.functions
+ def get_next_key(project: str, override_cache: bool = False) -> str:
- def get_next_key(project: str) -> str:
+ keys: List[str] = await get_keys(
- keys: List[str] = await get_keys(project)
+ project, ignore_cache=override_cache, update_cache=override_cache
+ )
if len(keys) == 0:
return ""
return keys[randint(0, len(keys) - 1)]
|
backend.src.routers.users.svg/get_user_repo_svg
|
Modified
|
avgupta456~github-trends
|
0e36c7255808cc3b687d276bda3a2c2c999c4744
|
overwrite demo caching
|
<0>:<add> output, time_str = await svg_base(
<add> user_id, start_date, end_date, time_range, demo, no_cache
<add> )
<del> output, time_str = await svg_base(user_id, start_date, end_date, time_range, demo)
|
<s>async def get_user_repo_svg(
response: Response,
user_id: str,
start_date: date = date.today() - timedelta(30),
end_date: date = date.today(),
time_range: str = "one_year",
timezone_str: str = "US/Eastern",
include_private: bool = False,
loc_metric: str = "added",
demo: bool = False,
+ no_cache: bool = False,
) -> Any:
<0> output, time_str = await svg_base(user_id, start_date, end_date, time_range, demo)
<1>
<2> # if no data, return loading svg
<3> if output is None:
<4> return get_loading_svg()
<5>
<6> # get top repos
<7> processed, commits_excluded = get_top_repos(output, loc_metric, include_private)
<8> return get_top_repos_svg(processed, time_str, loc_metric, commits_excluded)
<9>
|
===========unchanged ref 0===========
at: backend.src.routers.users.svg
router = APIRouter()
at: backend.src.routers.users.svg.get_user_lang_svg
output, time_str = await svg_base(
user_id, start_date, end_date, time_range, demo, no_cache
)
output, time_str = await svg_base(
user_id, start_date, end_date, time_range, demo, no_cache
)
at: datetime
timedelta(days: float=..., seconds: float=..., microseconds: float=..., milliseconds: float=..., minutes: float=..., hours: float=..., weeks: float=..., *, fold: int=...)
date()
at: datetime.date
today() -> _S
at: src.analytics.user.commits
get_top_languages(data: UserPackage, loc_metric: str, include_private: bool) -> Tuple[List[LanguageStats], int]
at: src.helper.decorators
svg_fail_gracefully(func: Callable[..., Any])
at: src.svg.error
get_loading_svg() -> Drawing
at: src.svg.top_langs
get_top_langs_svg(data: List[LanguageStats], time_str: str, use_percent: bool, loc_metric: str, commits_excluded: int, compact: bool) -> Drawing
===========changed ref 0===========
<s> user_id: str,
start_date: date = date.today() - timedelta(30),
end_date: date = date.today(),
time_range: str = "one_year",
timezone_str: str = "US/Eastern",
use_percent: bool = False,
include_private: bool = False,
loc_metric: str = "added",
compact: bool = False,
demo: bool = False,
+ no_cache: bool = False,
) -> Any:
+ output, time_str = await svg_base(
+ user_id, start_date, end_date, time_range, demo, no_cache
+ )
- output, time_str = await svg_base(user_id, start_date, end_date, time_range, demo)
# if no data, return loading svg
if output is None:
return get_loading_svg()
# get top languages
processed, num_excluded = get_top_languages(output, loc_metric, include_private)
return get_top_langs_svg(
processed, time_str, use_percent, loc_metric, num_excluded, compact
)
===========changed ref 1===========
# module: backend.src.routers.users.svg
def svg_base(
+ user_id: str,
+ start_date: date,
+ end_date: date,
+ time_range: str,
+ demo: bool,
+ no_cache: bool = False,
- user_id: str, start_date: date, end_date: date, time_range: str, demo: bool
) -> Tuple[Optional[UserPackage], str]:
# process time_range, start_date, end_date
time_range = "one_month" if demo else time_range
start_date, end_date, time_str = use_time_range(time_range, start_date, end_date)
# fetch data, either using demo or user method
if demo:
+ output = await get_user_demo(
+ user_id, start_date, end_date, ignore_cache=no_cache, update_cache=no_cache
+ )
- output = await get_user_demo(user_id, start_date, end_date)
else:
output = await get_user(user_id, start_date, end_date)
return output, time_str
===========changed ref 2===========
# module: backend.src.db.secret.functions
+ def get_next_key(project: str, override_cache: bool = False) -> str:
- def get_next_key(project: str) -> str:
+ keys: List[str] = await get_keys(
- keys: List[str] = await get_keys(project)
+ project, ignore_cache=override_cache, update_cache=override_cache
+ )
if len(keys) == 0:
return ""
return keys[randint(0, len(keys) - 1)]
|
backend.src.routers.users.get_data/get_user_demo
|
Modified
|
avgupta456~github-trends
|
0e36c7255808cc3b687d276bda3a2c2c999c4744
|
overwrite demo caching
|
<0>:<add> access_token = await get_next_key(
<del> access_token = await get_next_key("demo")
<1>:<add> "demo", override_cache=(ignore_cache and update_cache)
<add> )
|
# module: backend.src.routers.users.get_data
@alru_cache()
+ async def get_user_demo(
+ user_id: str,
+ start_date: date,
+ end_date: date,
+ ignore_cache: bool = False,
+ update_cache: bool = False,
+ ) -> UserPackage:
- async def get_user_demo(user_id: str, start_date: date, end_date: date) -> UserPackage:
<0> access_token = await get_next_key("demo")
<1> data = await get_data(user_id, access_token, start_date, end_date)
<2> return (True, data) # type: ignore
<3>
|
===========unchanged ref 0===========
at: datetime
date()
at: src.helper.alru_cache
alru_cache(max_size: int=128, ttl: timedelta=timedelta(minutes=5))
===========changed ref 0===========
# module: backend.src.db.secret.functions
+ def get_next_key(project: str, override_cache: bool = False) -> str:
- def get_next_key(project: str) -> str:
+ keys: List[str] = await get_keys(
- keys: List[str] = await get_keys(project)
+ project, ignore_cache=override_cache, update_cache=override_cache
+ )
if len(keys) == 0:
return ""
return keys[randint(0, len(keys) - 1)]
===========changed ref 1===========
<s>async def get_user_repo_svg(
response: Response,
user_id: str,
start_date: date = date.today() - timedelta(30),
end_date: date = date.today(),
time_range: str = "one_year",
timezone_str: str = "US/Eastern",
include_private: bool = False,
loc_metric: str = "added",
demo: bool = False,
+ no_cache: bool = False,
) -> Any:
+ output, time_str = await svg_base(
+ user_id, start_date, end_date, time_range, demo, no_cache
+ )
- output, time_str = await svg_base(user_id, start_date, end_date, time_range, demo)
# if no data, return loading svg
if output is None:
return get_loading_svg()
# get top repos
processed, commits_excluded = get_top_repos(output, loc_metric, include_private)
return get_top_repos_svg(processed, time_str, loc_metric, commits_excluded)
===========changed ref 2===========
<s> user_id: str,
start_date: date = date.today() - timedelta(30),
end_date: date = date.today(),
time_range: str = "one_year",
timezone_str: str = "US/Eastern",
use_percent: bool = False,
include_private: bool = False,
loc_metric: str = "added",
compact: bool = False,
demo: bool = False,
+ no_cache: bool = False,
) -> Any:
+ output, time_str = await svg_base(
+ user_id, start_date, end_date, time_range, demo, no_cache
+ )
- output, time_str = await svg_base(user_id, start_date, end_date, time_range, demo)
# if no data, return loading svg
if output is None:
return get_loading_svg()
# get top languages
processed, num_excluded = get_top_languages(output, loc_metric, include_private)
return get_top_langs_svg(
processed, time_str, use_percent, loc_metric, num_excluded, compact
)
===========changed ref 3===========
# module: backend.src.routers.users.svg
def svg_base(
+ user_id: str,
+ start_date: date,
+ end_date: date,
+ time_range: str,
+ demo: bool,
+ no_cache: bool = False,
- user_id: str, start_date: date, end_date: date, time_range: str, demo: bool
) -> Tuple[Optional[UserPackage], str]:
# process time_range, start_date, end_date
time_range = "one_month" if demo else time_range
start_date, end_date, time_str = use_time_range(time_range, start_date, end_date)
# fetch data, either using demo or user method
if demo:
+ output = await get_user_demo(
+ user_id, start_date, end_date, ignore_cache=no_cache, update_cache=no_cache
+ )
- output = await get_user_demo(user_id, start_date, end_date)
else:
output = await get_user(user_id, start_date, end_date)
return output, time_str
|
backend.src.routers.users.db/get_db_user
|
Modified
|
avgupta456~github-trends
|
32f51e57d7b831a8fa4368a65bb5bbfcb2060ab4
|
override cache on svg routes
|
<0>:<add> return await get_user_by_user_id(
<del> return await get_user_by_user_id(user_id)
<1>:<add> user_id, ignore_cache=no_cache, update_cache=no_cache
<add> )
|
# module: backend.src.routers.users.db
@router.get("/get/{user_id}", status_code=status.HTTP_200_OK)
@async_fail_gracefully
+ async def get_db_user(
+ response: Response, user_id: str, no_cache: bool = False
+ ) -> Optional[DBUserModel]:
- async def get_db_user(response: Response, user_id: str) -> Optional[DBUserModel]:
<0> return await get_user_by_user_id(user_id)
<1>
|
===========unchanged ref 0===========
at: backend.src.routers.users.db
router = APIRouter()
at: src.helper.decorators
async_fail_gracefully(func: Callable[..., Any])
|
backend.src.routers.users.svg/svg_base
|
Modified
|
avgupta456~github-trends
|
32f51e57d7b831a8fa4368a65bb5bbfcb2060ab4
|
override cache on svg routes
|
<10>:<add> output = await get_user(
<add> user_id, start_date, end_date, ignore_cache=no_cache, update_cache=no_cache
<add> )
<del> output = await get_user(user_id, start_date, end_date)
|
# module: backend.src.routers.users.svg
def svg_base(
user_id: str,
start_date: date,
end_date: date,
time_range: str,
demo: bool,
no_cache: bool = False,
) -> Tuple[Optional[UserPackage], str]:
<0> # process time_range, start_date, end_date
<1> time_range = "one_month" if demo else time_range
<2> start_date, end_date, time_str = use_time_range(time_range, start_date, end_date)
<3>
<4> # fetch data, either using demo or user method
<5> if demo:
<6> output = await get_user_demo(
<7> user_id, start_date, end_date, ignore_cache=no_cache, update_cache=no_cache
<8> )
<9> else:
<10> output = await get_user(user_id, start_date, end_date)
<11>
<12> return output, time_str
<13>
|
===========unchanged ref 0===========
at: datetime
date()
at: src.helper.utils
use_time_range(time_range: str, start_date: date, end_date: date) -> Tuple[date, date, str]
at: src.routers.users.get_data
Callable(*args: List[Any], **kwargs: Dict[str, Any]) -> Any
Callable(*args: List[Any], **kwargs: Dict[str, Any]) -> Any
at: typing
Tuple = _TupleType(tuple, -1, inst=False, name='Tuple')
===========changed ref 0===========
# module: backend.src.routers.users.db
@router.get("/get/{user_id}", status_code=status.HTTP_200_OK)
@async_fail_gracefully
+ async def get_db_user(
+ response: Response, user_id: str, no_cache: bool = False
+ ) -> Optional[DBUserModel]:
- async def get_db_user(response: Response, user_id: str) -> Optional[DBUserModel]:
+ return await get_user_by_user_id(
- return await get_user_by_user_id(user_id)
+ user_id, ignore_cache=no_cache, update_cache=no_cache
+ )
|
backend.src.routers.users.dev/get_user_raw
|
Modified
|
avgupta456~github-trends
|
32f51e57d7b831a8fa4368a65bb5bbfcb2060ab4
|
override cache on svg routes
|
<2>:<add> db_user = await get_user_by_user_id(
<del> db_user = await get_user_by_user_id(user_id, use_cache=False)
<3>:<add> user_id, ignore_cache=True, update_cache=True
<add> )
<9>:<del> print(start_date, end_date, user_id, new_access_token, timezone_str)
<12>:<add> print("Query Limit Used", start_query_limit - end_query_limit)
<del> print("query limit used", start_query_limit - end_query_limit)
<13>:<add> print("Query Limit Remaining", end_query_limit)
<del> print("query limit remaining", end_query_limit)
|
<s>user_id}", status_code=status.HTTP_200_OK)
@async_fail_gracefully
async def get_user_raw(
response: Response,
user_id: str,
access_token: Optional[str] = None,
start_date: date = date.today() - timedelta(365),
end_date: date = date.today(),
time_range: str = "one_month",
timezone_str: str = "US/Eastern",
) -> UserPackage:
<0> new_access_token: str = access_token if access_token else ""
<1> if not access_token:
<2> db_user = await get_user_by_user_id(user_id, use_cache=False)
<3> if db_user is None or db_user.access_token == "":
<4> raise LookupError("Invalid UserId")
<5> new_access_token = db_user.access_token
<6>
<7> start_query_limit = get_query_limit(access_token=new_access_token)
<8> start_date, end_date, _ = use_time_range(time_range, start_date, end_date)
<9> print(start_date, end_date, user_id, new_access_token, timezone_str)
<10> data = await get_data(user_id, new_access_token, start_date, end_date, timezone_str)
<11> end_query_limit = get_query_limit(access_token=new_access_token)
<12> print("query limit used", start_query_limit - end_query_limit)
<13> print("query limit remaining", end_query_limit)
<14>
<15> return data
<16>
|
===========unchanged ref 0===========
at: backend.src.routers.users.dev
router = APIRouter()
at: datetime
timedelta(days: float=..., seconds: float=..., microseconds: float=..., milliseconds: float=..., minutes: float=..., hours: float=..., weeks: float=..., *, fold: int=...)
date()
at: datetime.date
__slots__ = '_year', '_month', '_day', '_hashcode'
today() -> _S
__str__ = isoformat
__radd__ = __add__
at: src.db.user.get
Callable(*args: List[Any], **kwargs: Dict[str, Any]) -> Any
at: src.external.github_api.graphql.template
get_query_limit(access_token: str) -> int
at: src.helper.decorators
async_fail_gracefully(func: Callable[..., Any])
at: src.helper.utils
use_time_range(time_range: str, start_date: date, end_date: date) -> Tuple[date, date, str]
at: src.packaging.user
main(user_id: str, access_token: str, start_date: date, end_date: date, timezone_str: str="US/Eastern") -> UserPackage
===========changed ref 0===========
# module: backend.src.routers.users.db
@router.get("/get/{user_id}", status_code=status.HTTP_200_OK)
@async_fail_gracefully
+ async def get_db_user(
+ response: Response, user_id: str, no_cache: bool = False
+ ) -> Optional[DBUserModel]:
- async def get_db_user(response: Response, user_id: str) -> Optional[DBUserModel]:
+ return await get_user_by_user_id(
- return await get_user_by_user_id(user_id)
+ user_id, ignore_cache=no_cache, update_cache=no_cache
+ )
===========changed ref 1===========
# module: backend.src.routers.users.svg
def svg_base(
user_id: str,
start_date: date,
end_date: date,
time_range: str,
demo: bool,
no_cache: bool = False,
) -> Tuple[Optional[UserPackage], str]:
# process time_range, start_date, end_date
time_range = "one_month" if demo else time_range
start_date, end_date, time_str = use_time_range(time_range, start_date, end_date)
# fetch data, either using demo or user method
if demo:
output = await get_user_demo(
user_id, start_date, end_date, ignore_cache=no_cache, update_cache=no_cache
)
else:
+ output = await get_user(
+ user_id, start_date, end_date, ignore_cache=no_cache, update_cache=no_cache
+ )
- output = await get_user(user_id, start_date, end_date)
return output, time_str
|
backend.src.routers.users.main/get_user_endpoint
|
Modified
|
avgupta456~github-trends
|
32f51e57d7b831a8fa4368a65bb5bbfcb2060ab4
|
override cache on svg routes
|
<0>:<add> return await get_user(
<add> user_id, start_date, end_date, ignore_cache=no_cache, update_cache=no_cache
<add> )
<del> return await get_user(user_id, start_date, end_date)
|
<s>routers.users.main
@router.get("/{user_id}", status_code=status.HTTP_200_OK)
@async_fail_gracefully
async def get_user_endpoint(
response: Response,
user_id: str,
start_date: date = date.today() - timedelta(365),
end_date: date = date.today(),
timezone_str: str = "US/Eastern",
+ no_cache: bool = False,
) -> Optional[UserPackage]:
<0> return await get_user(user_id, start_date, end_date)
<1>
|
===========unchanged ref 0===========
at: backend.src.routers.users.main
router = APIRouter()
at: datetime
timedelta(days: float=..., seconds: float=..., microseconds: float=..., milliseconds: float=..., minutes: float=..., hours: float=..., weeks: float=..., *, fold: int=...)
date()
at: datetime.date
__slots__ = '_year', '_month', '_day', '_hashcode'
today() -> _S
__str__ = isoformat
__radd__ = __add__
at: src.helper.decorators
async_fail_gracefully(func: Callable[..., Any])
===========changed ref 0===========
# module: backend.src.routers.users.db
@router.get("/get/{user_id}", status_code=status.HTTP_200_OK)
@async_fail_gracefully
+ async def get_db_user(
+ response: Response, user_id: str, no_cache: bool = False
+ ) -> Optional[DBUserModel]:
- async def get_db_user(response: Response, user_id: str) -> Optional[DBUserModel]:
+ return await get_user_by_user_id(
- return await get_user_by_user_id(user_id)
+ user_id, ignore_cache=no_cache, update_cache=no_cache
+ )
===========changed ref 1===========
# module: backend.src.routers.users.svg
def svg_base(
user_id: str,
start_date: date,
end_date: date,
time_range: str,
demo: bool,
no_cache: bool = False,
) -> Tuple[Optional[UserPackage], str]:
# process time_range, start_date, end_date
time_range = "one_month" if demo else time_range
start_date, end_date, time_str = use_time_range(time_range, start_date, end_date)
# fetch data, either using demo or user method
if demo:
output = await get_user_demo(
user_id, start_date, end_date, ignore_cache=no_cache, update_cache=no_cache
)
else:
+ output = await get_user(
+ user_id, start_date, end_date, ignore_cache=no_cache, update_cache=no_cache
+ )
- output = await get_user(user_id, start_date, end_date)
return output, time_str
===========changed ref 2===========
<s>user_id}", status_code=status.HTTP_200_OK)
@async_fail_gracefully
async def get_user_raw(
response: Response,
user_id: str,
access_token: Optional[str] = None,
start_date: date = date.today() - timedelta(365),
end_date: date = date.today(),
time_range: str = "one_month",
timezone_str: str = "US/Eastern",
) -> UserPackage:
new_access_token: str = access_token if access_token else ""
if not access_token:
+ db_user = await get_user_by_user_id(
- db_user = await get_user_by_user_id(user_id, use_cache=False)
+ user_id, ignore_cache=True, update_cache=True
+ )
if db_user is None or db_user.access_token == "":
raise LookupError("Invalid UserId")
new_access_token = db_user.access_token
start_query_limit = get_query_limit(access_token=new_access_token)
start_date, end_date, _ = use_time_range(time_range, start_date, end_date)
- print(start_date, end_date, user_id, new_access_token, timezone_str)
data = await get_data(user_id, new_access_token, start_date, end_date, timezone_str)
end_query_limit = get_query_limit(access_token=new_access_token)
+ print("Query Limit Used", start_query_limit - end_query_limit)
- print("query limit used", start_query_limit - end_query_limit)
+ print("Query Limit Remaining", end_query_limit)
- print("query limit remaining", end_query_limit)
return data
|
backend.src.routers.users.get_data/_get_user
|
Modified
|
avgupta456~github-trends
|
32f51e57d7b831a8fa4368a65bb5bbfcb2060ab4
|
override cache on svg routes
|
<3>:<add> db_user: Optional[UserModel] = await get_user_by_user_id(
<del> db_user: Optional[UserModel] = await get_user_by_user_id(user_id)
<4>:<add> user_id, ignore_cache=no_cache, update_cache=no_cache
<add> )
|
# module: backend.src.routers.users.get_data
+ def _get_user(user_id: str, no_cache: bool = False) -> Optional[UserPackage]:
- def _get_user(user_id: str) -> Optional[UserPackage]:
<0> if not PUBSUB_PUB:
<1> raise HTTPException(400, "")
<2>
<3> db_user: Optional[UserModel] = await get_user_by_user_id(user_id)
<4> if db_user is None or db_user.access_token == "":
<5> raise LookupError("Invalid UserId")
<6>
<7> last_updated: datetime = datetime(1970, 1, 1)
<8> if db_user.last_updated is not None:
<9> last_updated = db_user.last_updated
<10>
<11> time_diff = datetime.now() - last_updated
<12> if time_diff > timedelta(hours=6) or not validate_raw_data(db_user.raw_data):
<13> if db_user.lock is None or not db_user.lock:
<14> publish_to_topic(
<15> "user", {"user_id": user_id, "access_token": db_user.access_token}
<16> )
<17>
<18> if validate_raw_data(db_user.raw_data):
<19> return db_user.raw_data # type: ignore
<20>
<21> return None
<22>
|
===========unchanged ref 0===========
at: backend.src.routers.users.get_data
validate_raw_data(data: Optional[UserPackage]) -> bool
at: datetime
timedelta(days: float=..., seconds: float=..., microseconds: float=..., milliseconds: float=..., minutes: float=..., hours: float=..., weeks: float=..., *, fold: int=...)
datetime()
at: datetime.datetime
__slots__ = date.__slots__ + time.__slots__
now(tz: Optional[_tzinfo]=...) -> _S
__radd__ = __add__
at: src.constants
PUBSUB_PUB = os.getenv("PUBSUB_PUB", "False") == "True"
at: src.db.user.get
Callable(*args: List[Any], **kwargs: Dict[str, Any]) -> Any
at: src.db.user.models.UserModel
user_id: str
access_token: str
last_updated: Optional[datetime]
raw_data: Optional[UserPackage]
lock: Optional[bool]
at: src.external.pubsub.templates
publish_to_topic(topic: str, message: Dict[str, Any]) -> None
===========changed ref 0===========
# module: backend.src.routers.users.db
@router.get("/get/{user_id}", status_code=status.HTTP_200_OK)
@async_fail_gracefully
+ async def get_db_user(
+ response: Response, user_id: str, no_cache: bool = False
+ ) -> Optional[DBUserModel]:
- async def get_db_user(response: Response, user_id: str) -> Optional[DBUserModel]:
+ return await get_user_by_user_id(
- return await get_user_by_user_id(user_id)
+ user_id, ignore_cache=no_cache, update_cache=no_cache
+ )
===========changed ref 1===========
<s>routers.users.main
@router.get("/{user_id}", status_code=status.HTTP_200_OK)
@async_fail_gracefully
async def get_user_endpoint(
response: Response,
user_id: str,
start_date: date = date.today() - timedelta(365),
end_date: date = date.today(),
timezone_str: str = "US/Eastern",
+ no_cache: bool = False,
) -> Optional[UserPackage]:
+ return await get_user(
+ user_id, start_date, end_date, ignore_cache=no_cache, update_cache=no_cache
+ )
- return await get_user(user_id, start_date, end_date)
===========changed ref 2===========
# module: backend.src.routers.users.svg
def svg_base(
user_id: str,
start_date: date,
end_date: date,
time_range: str,
demo: bool,
no_cache: bool = False,
) -> Tuple[Optional[UserPackage], str]:
# process time_range, start_date, end_date
time_range = "one_month" if demo else time_range
start_date, end_date, time_str = use_time_range(time_range, start_date, end_date)
# fetch data, either using demo or user method
if demo:
output = await get_user_demo(
user_id, start_date, end_date, ignore_cache=no_cache, update_cache=no_cache
)
else:
+ output = await get_user(
+ user_id, start_date, end_date, ignore_cache=no_cache, update_cache=no_cache
+ )
- output = await get_user(user_id, start_date, end_date)
return output, time_str
===========changed ref 3===========
<s>user_id}", status_code=status.HTTP_200_OK)
@async_fail_gracefully
async def get_user_raw(
response: Response,
user_id: str,
access_token: Optional[str] = None,
start_date: date = date.today() - timedelta(365),
end_date: date = date.today(),
time_range: str = "one_month",
timezone_str: str = "US/Eastern",
) -> UserPackage:
new_access_token: str = access_token if access_token else ""
if not access_token:
+ db_user = await get_user_by_user_id(
- db_user = await get_user_by_user_id(user_id, use_cache=False)
+ user_id, ignore_cache=True, update_cache=True
+ )
if db_user is None or db_user.access_token == "":
raise LookupError("Invalid UserId")
new_access_token = db_user.access_token
start_query_limit = get_query_limit(access_token=new_access_token)
start_date, end_date, _ = use_time_range(time_range, start_date, end_date)
- print(start_date, end_date, user_id, new_access_token, timezone_str)
data = await get_data(user_id, new_access_token, start_date, end_date, timezone_str)
end_query_limit = get_query_limit(access_token=new_access_token)
+ print("Query Limit Used", start_query_limit - end_query_limit)
- print("query limit used", start_query_limit - end_query_limit)
+ print("Query Limit Remaining", end_query_limit)
- print("query limit remaining", end_query_limit)
return data
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.