prepare release

Author: GermanMT

.github/workflows/analisys.yml

@@ -15,7 +15,7 @@ jobs:
         run: |
           python -m pip install --upgrade pip
           pip install -r requirements.txt
-          pip install ruff==0.1.5
+          pip install ruff==0.1.11
       - name: Analysing the code with ruff
         run: |
           ruff check .

Dockerfile

@@ -1,4 +1,4 @@
-FROM python:3.12.0
+FROM python:3.12.1
 
 WORKDIR /depex
 

app/main.py

@@ -42,7 +42,7 @@ async def lifespan(app: FastAPI) -> None:
 app = FastAPI(
     title="Depex",
     description=DESCRIPTION,
-    version="0.6.1",
+    version="0.6.2",
     contact={
         "name": "Antonio Germán Márquez Trujillo",
         "url": "https://github.com/GermanMT",

app/services/__init__.py

@@ -17,7 +17,6 @@
     read_packages_by_requirement_file,
     relate_packages,
     update_package_moment,
-    parent_depth
 )
 from .repository_service import (
     create_repository,
@@ -57,7 +56,6 @@
     "read_packages_by_requirement_file",
     "relate_packages",
     "update_package_moment",
-    "parent_depth",
     "create_repository",
     "read_repositories_moment",
     "read_repositories",

app/services/package_service.py

@@ -4,59 +4,18 @@
 from .dbs.databases import get_graph_db_session
 
 
-async def parent_depth(new_req_file_id: str, package_name: str, package_manager: str) -> int:
-    query = """
-    match (rf:RequirementFile) where elementid(rf) = $new_req_file_id
-    match (p:Package) where p.name = $package_name
-    with shortestPath((rf)-[*..]->(p)) as p
-    return length(p)
-    """
-    session = get_graph_db_session(package_manager)
-    result = await session.run(query, new_req_file_id=new_req_file_id, package_name=package_name)
-    record = await result.single()
-    return record[0] if record else None
-
-
-# async def create_package_and_versions(
-#     package: dict[str, Any],
-#     versions: list[dict[str, Any]],
-#     package_manager: str,
-# ) -> list[dict[str, str]]:
-#     query_part = f"{{name:$name,{"group_id:$group_id," if package_manager == "MVN" else ""}moment:$moment}}"
-#     query = f"""
-#     create(p:Package{query_part})
-#     with p as package
-#     unwind $versions as version
-#     create(v:Version{{
-#         name: version.name,
-#         release_date: version.release_date,
-#         count: version.count,
-#         cves: version.cves,
-#         mean: version.mean,
-#         weighted_mean: version.weighted_mean
-#     }})
-#     create (package)-[rel_v:Have]->(v)
-#     return collect({{name: v.name, id: elementid(v)}})
-#     """
-#     session = get_graph_db_session(package_manager)
-#     result = await session.run(query, package, versions=versions)
-#     record = await result.single()
-#     return record[0] if record else None
-
-
 async def create_package_and_versions_with_parent2(
     package: dict[str, Any],
     versions: list[dict[str, Any]],
     constraints: list[str] | str,
     parent_id: str,
     package_manager: str,
 ) -> list[dict[str, str]]:
-    query_part1 = f"{{name:$name,{"group_id:$group_id," if package_manager == "MVN" else ""}moment:$moment}}"
-    query_part2 = f"{{name:$name,{"group_id:$group_id," if package_manager == "MVN" else ""}moment:$moment}}"
+    query_part = f"{{name:$name,{"group_id:$group_id," if package_manager == "MVN" else ""}moment:$moment}}"
     query = f"""
     match (parent:RequirementFile|Version)
     where elementid(parent) = $parent_id
-    create(p:Package{query_part1})
+    create(p:Package{query_part})
     create (parent)-[rel_p:Requires{{constraints:$constraints}}]->(p)
     with p as package
     unwind $versions as version
@@ -85,14 +44,22 @@ async def create_package_and_versions(
     package_manager: str,
     constraints: str | None = None,
     parent_id: str | None = None,
-    parent_version_name: str | None = None
+    parent_version_name: str | None = None,
 ) -> list[dict[str, str]]:
-    query_part1 = ("""
+    query_part1 = (
+        """
         match (parent:RequirementFile|Version)
         where elementid(parent) = $parent_id
-        """ if parent_id else "")
+        """
+        if parent_id
+        else ""
+    )
     query_part2 = f"{{name:$name,{"group_id:$group_id," if package_manager == "MVN" else ""}moment:$moment}}"
-    query_part3 = f"create (parent)-[rel_p:Requires{{constraints:$constraints{", parent_version_name:$parent_version_name" if parent_version_name else ""}}}]->(p)" if parent_id else ""
+    query_part3 = (
+        f"create (parent)-[rel_p:Requires{{constraints:$constraints{", parent_version_name:$parent_version_name" if parent_version_name else ""}}}]->(p)"
+        if parent_id
+        else ""
+    )
     query = f"""
     {query_part1}
     create(p:Package{query_part2})
@@ -112,7 +79,12 @@ async def create_package_and_versions(
     """
     session = get_graph_db_session(package_manager)
     result = await session.run(
-        query, package, constraints=constraints, parent_id=parent_id, parent_version_name=parent_version_name, versions=versions
+        query,
+        package,
+        constraints=constraints,
+        parent_id=parent_id,
+        parent_version_name=parent_version_name,
+        versions=versions,
     )
     record = await result.single()
     return record[0] if record else None
@@ -147,22 +119,6 @@ async def read_packages_by_requirement_file(
     return record[0] if record else None
 
 
-# TODO: Mejorar esta query
-# TODO: Probar nueva query transformación a smt
-# TODO: Probar algoritmo creación en anchura
-
-# async def relate_packages2(packages: list[dict(str, str)], package_manager: str) -> None:
-#     query = """
-#     unwind keys($packages) as package
-#     match (p:Package) where p.name = package.package_name
-#     with p, package unwind $packages[package] as parent_id
-#     match (parent:Version) where elementid(parent) = parent_id
-#     create (parent)-[rel:Requires{constraints: package.constraints}]->(p:Package)
-#     """
-#     session = get_graph_db_session(package_manager)
-#     await session.run(query, packages=packages)
-
-
 async def relate_packages(packages: list[dict[str, Any]], package_manager: str) -> None:
     query = """
     unwind $packages as package

app/services/repository_service.py

@@ -121,7 +121,11 @@ async def read_graph_for_info_operation(
     return {dependencies: size(deps), edges: size(rels), cves: apoc.coll.toSet(cves)}
     """
     session = get_graph_db_session(package_manager)
-    result = await session.run(query, requirement_file_id=requirement_file_id, max_level=max_level * 2 if max_level != -1 else max_level)
+    result = await session.run(
+        query,
+        requirement_file_id=requirement_file_id,
+        max_level=max_level * 2 if max_level != -1 else max_level,
+    )
     record = await result.single()
     return record[0] if record else None
 
@@ -148,52 +152,21 @@ async def read_data_for_smt_transform(
             count: endnode(relationship).count,
             mean: endnode(relationship).mean,
             weighted_mean: endnode(relationship).weighted_mean
-        
+
     }
     end as have
     return {requires: apoc.coll.sortMaps(collect(requires), "parent_count"), have: apoc.map.groupByMulti(apoc.coll.sortMaps(collect(have), "count"), "dependency")}
     """
     session = get_graph_db_session(package_manager)
-    result = await session.run(query, requirement_file_id=requirement_file_id, max_level=max_level * 2 if max_level != -1 else max_level)
+    result = await session.run(
+        query,
+        requirement_file_id=requirement_file_id,
+        max_level=max_level * 2 if max_level != -1 else max_level,
+    )
     record = await result.single()
     return record[0] if record else None
 
 
-# async def read_data_for_smt_transform(
-#     requirement_file_id: str, package_manager: str, max_level: int
-# ) -> dict[str, Any]:
-#     query = """
-#     match (rf: RequirementFile) where elementid(rf) = $requirement_file_id
-#     call apoc.path.subgraphAll(rf, {relationshipFilter: '>', maxLevel: $max_level}) yield relationships
-#     unwind relationships as relationship
-#     with case type(relationship)
-#     when 'Requires' then {
-#         parent_type: labels(startnode(relationship))[0],
-#         parent_id: elementid(startnode(relationship)),
-#         parent_name: startnode(relationship).name,
-#         parent_count: startnode(relationship).count,
-#         dependency: endnode(relationship).name,
-#         constraints: relationship.constraints
-#     }
-#     end as requires,
-#     case type(relationship)
-#     when 'Have' then {
-#         dependency: startnode(relationship).name,
-#         id: elementid(endnode(relationship)),
-#         release: endnode(relationship).name,
-#         count: endnode(relationship).count,
-#         mean: endnode(relationship).mean,
-#         weighted_mean: endnode(relationship).weighted_mean
-#     }
-#     end as have
-#     return {requires: collect(requires), have: collect(have)}
-#     """
-#     session = get_graph_db_session(package_manager)
-#     result = await session.run(query, requirement_file_id=requirement_file_id, max_level=max_level * 2 if max_level != -1 else max_level)
-#     record = await result.single()
-#     return record[0] if record else None
-
-
 async def update_repository_is_complete(
     repository_id: str, is_complete: bool, package_manager: str
 ) -> None:

app/utils/__init__.py

@@ -12,5 +12,5 @@
     "mean",
     "weighted_mean",
     "parse_pip_constraints",
-    "repo_analyzer"
+    "repo_analyzer",
 ]