collabnet 0.1.0__py3-none-any.whl

collabnet/analysis.py

@@ -0,0 +1,354 @@
+# Create networks from publication records.
+import json
+from itertools import combinations
+from pathlib import Path
+
+import igraph as ig
+import numpy as np
+import pandas as pd
+from tqdm import tqdm
+
+
+def _json_default(o):
+    # Make common non-JSON types serializable
+    try:
+        if isinstance(o, (np.integer, np.floating, np.bool_)):
+            return o.item()
+    except Exception:
+        pass
+    if isinstance(o, (set, tuple)):
+        return list(o)
+    raise TypeError(f"Object of type {type(o).__name__} is not JSON serializable")
+
+
+def _serialize_seq_attrs(seq):
+    # seq is g.vs or g.es
+    attrs = list(seq.attributes())
+    for a in attrs:
+        vals = seq[a]
+        # If any value is not a GraphML primitive, serialize the entire column to JSON strings
+        if any(not (v is None or isinstance(v, (bool, int, float, str))) for v in vals):
+            seq[a] = [
+                json.dumps(
+                    v, default=_json_default, ensure_ascii=False, separators=(",", ":")
+                )
+                if v is not None
+                else None
+                for v in vals
+            ]
+
+
+def _serialize_graph_attrs(g: ig.Graph):
+    for a in list(g.attributes()):
+        v = g[a]
+        if not (v is None or isinstance(v, (bool, int, float, str))):
+            g[a] = json.dumps(
+                v, default=_json_default, ensure_ascii=False, separators=(",", ":")
+            )
+
+
+def write_graphml_with_json(g: ig.Graph, path: Path):
+    """Routine to JSON serialize entries in node or edge attributes."""
+    _serialize_seq_attrs(g.vs)
+    _serialize_seq_attrs(g.es)
+    _serialize_graph_attrs(g)
+    g.write_graphml(path.as_posix())
+
+
+class CreateNetwork:
+    """Create networks for co-author and co-country analysis
+
+    Builds time-sliced networks from a dataframe of OpenAlex works (e.g., as
+    produced by TransformOA). A time window can be defined as (year - window, year),
+    e.g. (1960 - 5, 1960) -> (1955, 1960), to gather all entries for that range in
+    one network.
+
+    Expected dataframe columns:
+        - publication_year: int
+        - authorships: list of (author_id, [institution_ids]) for coauthor mode
+        - countries: list[str] of ISO 3166-1 alpha-2 codes for cocountry mode
+
+
+    :param dataframe: Source records to derive networks from.
+    :type dataframe: pandas.DataFrame
+    :param year_range: Inclusive (start_year, end_year) for filtering works.
+    :type year_range: tuple[int, int]
+    :param interval: Size of each time window in years. Defaults to 1.
+    :type interval: int, optional
+    :param out_path: Directory where network files/exports will be written.
+    :type out_path: pathlib.Path, optional
+    :param net_type: Network type to build: "coauthor" or "cocountry".
+                        Defaults to "coauthor".
+    :type net_type: str, optional
+    """
+
+    def __init__(
+        self,
+        dataframe: pd.DataFrame,
+        year_range: tuple,
+        interval: int = 1,
+        out_path: Path = Path("."),
+        net_type: str = "coauthor",
+    ):
+        """Init class."""
+        self.dataframe = dataframe
+        self.year_range = year_range
+        self.interval = interval
+        self.out_path = out_path
+        self.net_type = net_type
+
+    def run(self) -> str:
+        self._write_graphml()
+        return "Done"
+
+    def _create_edge(self, row: dict) -> list:
+        """Create all co-author edges for a single publication record.
+
+        Generates unordered author pairs (nC2) from the `authorships` field of the
+        input row. Any author entries with missing/None IDs are ignored. Single-
+        author publications yield no edges.
+
+        Expected input structure:
+            - row["authorships"]: list of (author_id, [institution_ids])
+
+        where author_id may be str or None.
+
+        Optional fields (copied into edge metadata if present):
+            - row["id"], row["doi"], row["title"], row["type"],
+            - row["publication_year"], row["countries"], row["topics"],
+            - row["primary_location"], row["referenced_works"], etc.
+
+        Returned edge format:
+            - A list of tuples (author_u, author_v, metadata)
+
+            where:
+            - author_u: str — source author ID
+            - author_v: str — target author ID
+            - metadata: dict — publication-level attributes carried from `row`
+
+        (contents depend on available keys)
+
+        Notes:
+            - Pairs are unique combinations (no self-pairs, order-independent).
+            - Entries with missing author IDs are skipped.
+
+        :param row: Publication record providing authorships and optional metadata.
+        :type row: dict | pandas.Series
+        :returns: List of co-author edges with metadata for the given publication.
+        :rtype: list[tuple[str, str, dict]]
+        :raises KeyError: If 'authorships' is missing from the input row.
+        :raises TypeError: If 'authorships' is not iterable.
+        """
+        list_entry = []
+        if self.net_type == "coauthor":
+            key = "authorships"
+        elif self.net_type == "cocountry":
+            key = "countries"
+        else:
+            raise KeyError("Please select net_type equals coauthor or cocountry.")
+        if len(row[key]) > 2:
+            pairs = combinations(row[key], 2)
+            for pair in pairs:
+                if None not in pair:
+                    # Handle different data structure of author and country entries
+                    if self.net_type == "coauthor":
+                        src = pair[0][0]
+                        trg = pair[1][0]
+                    else:
+                        src = pair[0]
+                        trg = pair[1]
+                    list_entry.append(
+                        (
+                            src,
+                            trg,
+                            1,
+                            row["id"],
+                            row["title"],
+                            int(row["publication_year"]),
+                            row["topics"],
+                        )
+                    )
+            return list_entry
+        return []
+
+    def _write_graphml(self):
+        """Build rolling-window networks and export them to GraphML files.
+
+        For each year in the inclusive range [year_range[0], year_range[1]], this
+        method:
+
+        1) Selects works with publication_year in [year - self.interval, year] (inclusive).
+        2) Creates per-publication co-occurrence edges via `_create_edge(row)`.
+        3) Flattens edges and aggregates by (source, target) to compute
+
+        - weight: number of co-occurrences in the window,
+        - paper: unique list of publication identifiers,
+        - years: unique list of publication years,
+        - topics: unique list aggregated across publications.
+
+        4) Builds an igraph Graph and writes a GraphML file named f"{self.net_type}_{year}.graphml" to `self.out_path`.
+
+        Expected dataframe columns and behavior:
+            - publication_year: int; used for time-window filtering.
+            - `_create_edge(row)` must return a list of tuples with the following order per edge: (source, target, weight, paper, title, years, topics)
+
+            where:
+                - source, target: author or country IDs (str-like),
+                - weight: typically 1 per publication-level edge,
+                - paper: publication/work identifier (e.g., OpenAlex ID),
+                - title: publication title (not used in aggregation),
+                - years: publication year (int),
+                - topics: list of topic IDs.
+
+            Single-actor rows should yield no edges.
+
+        :returns: None
+        :rtype: None
+        :raises KeyError: If required dataframe columns are missing (e.g., publication_year)
+                            or if `_create_edge` omits expected fields.
+        :raises ValueError: If edge tuples do not match the expected shape/order.
+        :raises ImportError: If igraph or required serialization utilities are missing.
+        :raises OSError: For I/O errors while writing GraphML files.
+        """
+        for year in tqdm(range(self.year_range[0], self.year_range[1] + 1, 1)):
+            entries = []
+            for idx, row in self.dataframe.query(
+                f"publication_year >= {year - self.interval} & publication_year <= {year}"
+            ).iterrows():
+                entries.append(self._create_edge(row))
+            edges = [x for y in entries for x in y]
+            dftemp = pd.DataFrame(
+                edges,
+                columns=[
+                    "source",
+                    "target",
+                    "weight",
+                    "paper",
+                    "title",
+                    "years",
+                    "topics",
+                ],
+            )
+            weighted_edges = []
+            for idx, g0 in dftemp.groupby(["source", "target"]):
+                weighted_edges.append(
+                    (
+                        idx[0],
+                        idx[1],
+                        g0.shape[0],
+                        list(g0.paper.unique()),
+                        list(g0.years.unique()),
+                        list(set([x for y in list(g0.topics.values) for x in y])),
+                    )
+                )
+            graph = ig.Graph.TupleList(
+                weighted_edges, edge_attrs=["weight", "paper", "years", "topics"]
+            )
+            write_graphml_with_json(
+                graph, self.out_path / f"{self.net_type}_{year}.graphml"
+            )
+
+
+class CalculateAICI:
+    """Calculate adjusted internationalization collaboration index.
+
+    Input dataframe generated by `collabnet.data.OpenAlex`.
+    """
+
+    def __init__(self, dataframe: pd.DataFrame) -> None:
+        """Init class."""
+        self.dataframe = dataframe
+
+    def _check_country_exist(self, row: dict) -> bool:
+        if row["countries"]:
+            return True
+        return False
+
+    def _check_no_country_exist(self, row: dict) -> bool:
+        if not row["countries"]:
+            return True
+        return False
+
+    def _check_is_international(self, row: dict) -> bool:
+        if row["countries"] and len(set(row["countries"])) > 1:
+            return True
+        else:
+            return False
+
+    def _generate_df(self, dataframe: pd.DataFrame) -> pd.DataFrame:
+        """Calculate AICI for the dataframe."""
+        article_per_year = dataframe.groupby("publication_year").size().to_dict()
+        affil_per_year = {}
+        no_affil_per_year = {}
+        is_international_per_year = {}
+        for idx, g0 in dataframe.groupby("publication_year"):
+            affil_per_year.update(
+                {
+                    idx: int(
+                        g0.apply(lambda x: self._check_country_exist(x), axis=1).sum()
+                    )
+                }
+            )
+            no_affil_per_year.update(
+                {
+                    idx: int(
+                        g0.apply(
+                            lambda x: self._check_no_country_exist(x), axis=1
+                        ).sum()
+                    )
+                }
+            )
+            is_international_per_year.update(
+                {
+                    idx: int(
+                        g0.apply(
+                            lambda x: self._check_is_international(x), axis=1
+                        ).sum()
+                    )
+                }
+            )
+        aici_df = pd.DataFrame(
+            [
+                article_per_year,
+                affil_per_year,
+                no_affil_per_year,
+                is_international_per_year,
+            ]
+        ).T.rename(
+            columns={0: "papers", 1: "with_affil", 2: "no_affil", 3: "is_international"}
+        )
+        aici_df = aici_df.reset_index().rename(columns={"index": "year"})
+        return aici_df
+
+    def complete_df(self) -> pd.DataFrame:
+        """Calculate values for full dataframe."""
+        dftemp = self._generate_df(self.dataframe)
+        dftemp.insert(0, "level", "global")
+        return dftemp
+
+    def country_df(self, country: str) -> pd.DataFrame:
+        """Calculate values for one country."""
+        country_mask = self.dataframe.countries.apply(
+            lambda x: True if country in x else False
+        )
+        dataframe = self.dataframe[country_mask].reset_index(drop=True)
+        dftemp = self._generate_df(dataframe)
+        dftemp.insert(0, "level", country)
+        return dftemp
+
+    def country_compare(self, country_list: list) -> pd.DataFrame:
+        """Create data to compare country AICI."""
+        complete_df = self.complete_df()
+        aici_complete = complete_df["is_international"]/complete_df["with_affil"]
+        complete_df.insert(0, "aici", aici_complete)
+        norm_series = complete_df[["year", "with_affil"]].set_index("year")["with_affil"]
+        df_list = [complete_df]
+        for country in country_list:
+            country_df = self.country_df(country)
+            aici_cnty = country_df.set_index("year")["is_international"]/norm_series
+            country_df = country_df.merge(
+                aici_cnty.to_frame("aici"), left_on="year", right_index=True
+            )
+            df_list.append(country_df)
+        data = pd.concat(df_list, ignore_index=True)
+        return data

collabnet/data.py

@@ -0,0 +1,230 @@
+# Transform source data to required format.
+# Source data can come from OpenAlex by using the utilites module.
+
+import json
+from pathlib import Path
+
+import pandas as pd
+import pyalex
+from tqdm import tqdm
+
+
+class TransformOA:
+    """Read and transform Open Alex data.
+
+    File list should be a list of file paths.
+    Source files have to be in JSON format.
+
+     Using TransformOA.run() has the following workflow:
+       1) Open the UTF-8 encoded JSON file.
+       2) Load a list of OpenAlex Work records.
+       3) Normalize each record via `_process_entry`.
+       4) Create a pandas DataFrame and write it as JSON to `self.out_path`
+          using the same base filename.
+
+     Side effects:
+       - Writes a JSON file to `<self.out_path>/<file_path.name>`.
+
+     Note:
+       - UnicodeDecodeError from the JSON files are  caught and logged.
+       - Other I/O and JSON parsing errors will propagate to the caller.
+
+    :param src_files: List of source file paths to JSON files containing OpenAlex records.
+    :type src_files: list[str] | list[pathlib.Path]
+    :param out_path: Directory where transformed outputs will be written. Defaults to the current directory.
+    :type out_path: str | pathlib.Path, optional
+    """
+
+    def __init__(self, src_files: list, out_path: str = "."):
+        """Init class."""
+        self.src_files = src_files
+        self.out_path = out_path
+
+    def _getAuthorAffilID(self, authors) -> tuple:
+        """Extract author and affiliation identifiers and associated country codes.
+
+        Expects the OpenAlex "authorships" structure:
+            - Each item should contain an "author" dict with an "id".
+            - Each item should contain an "institutions" list; each institution may have "id" and "country_code".
+
+        Returns a tuple:
+            - List of (author_id, [institution_ids]) pairs.
+            - List of country codes (one per institution encountered, duplicates possible).
+
+        Note: Missing keys are returned as empty dicts ({}).
+
+        :param authors: List of authorship entries from an OpenAlex Work.
+        :type authors: list[dict]
+        :returns: (author_affils, countries)
+                    where author_affils is list[tuple[str | dict, list[str | dict]]]
+                    and countries is list[str | dict]
+        :rtype: tuple[list[tuple[str | dict, list[str | dict]]], list[str | dict]]
+        :raises TypeError: If `authors` is not iterable.
+        """
+        result = []
+        countries = []
+        for author in authors:
+            idx = author.get("author", {}).get("id", {})
+            instList = []
+            institutions = author.get("institutions")
+            for ins in institutions:
+                instList.append(ins.get("id", {}))
+                countries.append(ins.get("country_code", {}))
+            result.append((idx, instList))
+        return result, countries
+
+    def _getTopicID(self, topics) -> list:
+        """Collect topic identifiers from an OpenAlex Work.
+
+        Expects a list of topic dicts, each with an "id" key.
+
+        Note: Missing keys are returned as empty dicts ({}).
+
+        :param topics: Topics section from an OpenAlex Work.
+        :type topics: list[dict]
+        :returns: List of topic IDs.
+        :rtype: list[str | dict]
+        :raises TypeError: If `topics` is not iterable.
+        """
+        result = []
+        for topic in topics:
+            result.append(topic.get("id", {}))
+        return result
+
+    def _getJournalID(self, publication_location) -> str | None:
+        """Return the source (journal) identifier from a Work's primary location.
+
+        Expects the "primary_location" structure:
+            - A dict containing a "source" dict with an "id" key.
+
+        :param publication_location: The Work's primary_location object.
+        :type publication_location: dict
+        :returns: Source ID if available; otherwise None.
+        :rtype: str | None
+        """
+        source = publication_location.get("source", {})
+        if source:
+            return source.get("id", {})
+        return None
+
+    def _process_entry(self, work: dict) -> dict:
+        """Normalize a single OpenAlex Work record.
+
+            Extracts a subset of fields from the raw work, reconstructs the abstract
+            from the abstract_inverted_index, replaces it with a plain-text abstract,
+            and enriches the record with processed authorships, countries, topics, and
+            primary_location identifiers.
+
+            Required input keys in `work` for transformations:
+              - abstract_inverted_index
+              - authorships
+              - topics
+              - primary_location
+
+            Output keys in the returned dict:
+              - abstract            (reconstructed from abstract_inverted_index)
+              - authorships         (processed via _getAuthorAffilID)
+              - countries           (derived from authors' affiliations)
+              - topics              (processed via _getTopicID)
+              - primary_location    (processed via _getJournalID)
+
+            The keys id, doi, title, type, publication_year and referenced_works are copied.
+
+            :param work: Raw OpenAlex Work object as returned by the API.
+            :type work: dict
+            :returns: Normalized work record with selected fields and derived values.
+            :rtype: dict
+            :raises TypeError: If `work` is not a mapping-like object.
+            :raises KeyError: If any required field is missing from `work`.
+            """
+        data_keys = [
+            "doi",
+            "title",
+            "type",
+            "publication_year",
+            "abstract_inverted_index",
+            "referenced_works",
+        ]
+        result = dict()
+        result = {"id": work["id"]}
+        for key in data_keys:
+            result.update({key: work[key]})
+        tempWork = pyalex.Work(result)
+        abstract = tempWork["abstract"]
+        result.update({"abstract": abstract})
+        result.pop("abstract_inverted_index", None)
+        authors, countries = self._getAuthorAffilID(work["authorships"])
+        result.update({"authorships": authors})
+        result.update({"countries": countries})
+        result.update({"topics": self._getTopicID(work["topics"])})
+        result.update(
+            {"primary_location": self._getJournalID(work["primary_location"])}
+        )
+        return result
+
+    def _process_file(self, file_path: Path) -> None:
+        """Transform one source JSON file into the normalized output format.
+
+        :param file_path: Path to a UTF-8 encoded JSON file containing a list of
+                            OpenAlex Work objects.
+        :type file_path: pathlib.Path
+        :returns: None
+        :rtype: None
+        :raises FileNotFoundError: If the input file does not exist.
+        :raises json.JSONDecodeError: If the file content is not valid JSON.
+        :raises OSError: For general I/O errors while reading or writing.
+        """
+        with open(Path(file_path), encoding="utf-8") as infile:
+            try:
+                data = json.load(infile)
+                result = [self._process_entry(work) for work in data]
+                dftemp = pd.DataFrame(result)
+                dftemp.to_json(f"{self.out_path}{file_path.name}")
+            except UnicodeDecodeError as r:
+                print("error in file", r)
+
+    def run(self) -> None:
+        """Process all source files defined in `self.src_files`.
+
+        Iterates over `self.src_files` with a progress bar and invokes
+        `_process_file` for each entry.
+
+        :returns: None
+        :rtype: None
+        """
+        for file_path in tqdm(self.src_files):
+            self._process_file(file_path)
+
+
+def join_to_df(
+    src_folder: Path, out_folder: Path = Path("."), selection: str = "*.json"
+) -> pd.DataFrame:
+    """Create combined dataframe from JSON files.
+    Entries are de-duplicated based on their work ID.
+
+    If only specific JSON files should be joined,
+    specify a regex pattern like 'works_s\*.json'.
+    Supports glob to search files in subfolders, e.g.
+    '\**/\*.json' for all JSON files in all subfolders.
+
+    :param src_folder: Root directory to search for input JSON files.
+    :type src_folder: pathlib.Path
+    :param out_folder: Directory where any outputs or artifacts may be written.
+                        Defaults to the current directory.
+    :type out_folder: pathlib.Path, optional
+    :param selection: Glob pattern used to select input JSON files relative to
+                        src_folder. Defaults to '\*.json'.
+    :type selection: str, optional
+    :returns: Combined dataframe of unique works from the selected JSON files.
+    :rtype: pandas.DataFrame
+    """
+    file_paths = list(src_folder.glob(selection))
+    df_list = []
+    for filepath in file_paths:
+        data = pd.read_json(filepath)
+        df_list.append(data)
+    data = pd.concat(df_list, ignore_index=True)
+    dedup_data = data.drop_duplicates(subset="id")
+    dedup_data.to_json(out_folder / "joined_data.json", lines=True, orient="records")
+    print(f"Deduplicated {data.shape[0] - dedup_data.shape[0]} entries.")
+    return dedup_data

collabnet/utils.py

@@ -0,0 +1,165 @@
+# Query OA for works in relation to a journal or topic
+
+import json
+from pathlib import Path
+
+import pyalex
+from tqdm import tqdm
+from validator_collection import validators
+
+pyalex.config.max_retries = 1
+pyalex.config.retry_backoff_factor = 0.1
+pyalex.config.retry_http_codes = [429, 500, 503]
+
+
+class QueryOA:
+    """Query Open Alex to receive publication records.
+
+    :param config_email: Contact email used for OpenAlex polite API requests.
+    :type config_email: str
+    :param query_list: List of query terms or identifiers to query against OpenAlex.
+    :type query_list: list
+    :param year_range: Inclusive (start_year, end_year) for filtering publication years.
+    :type year_range: tuple[int, int]
+    :param out_path: Directory where results/artifacts should be written. Defaults to the current directory.
+    :type out_path: pathlib.Path, optional
+    :param query_type: Type of query to perform ("journal", "topic", or "institution"). Defaults to "topic".
+    :type query_type: str, optional
+    """
+
+    def __init__(
+        self,
+        config_email: str,
+        query_list: list,
+        year_range: tuple,
+        out_path: Path = Path("."),
+        query_type: str = "topic",
+        n_max: int | None = None,
+    ):
+        assert query_type in ["topic", "journal", "institution"], (
+            "Use supported query type: topic, journal or institution"
+        )
+        if query_type == "topic":
+            assert all([x.startswith("t") for x in query_list]), (
+                "Provide list of correct topic IDs starting with t."
+            )
+        elif query_type == "journal":
+            assert all([x.startswith("s") for x in query_list]), (
+                "Provide list of correct journal IDs starting with s."
+            )
+        else:
+            pass
+        assert validators.email(config_email), "Provide a valid email address."
+        pyalex.config.email = config_email
+        self.query_list = query_list
+        self.query_type = query_type
+        self.year_range = year_range
+        self.out_path = out_path
+        self.n_max = n_max
+
+    def run(self) -> list:
+        file_list = self._run_query(
+            self.query_list, self.query_type, self.year_range, self.out_path
+        )
+        return file_list
+
+    def _run_query(self, query_list, query_type, year_range, out_path) -> list:
+        """Execute an OpenAlex query and collect publication records.
+
+        :param query_list: List of query terms or identifiers to query against OpenAlex.
+        :type query_list: list
+        :param query_type: Type of query to perform (e.g., "topic", "author", "source").
+        :type query_type: str
+        :param year_range: Inclusive (start_year, end_year) for filtering publication years.
+        :type year_range: tuple[int, int]
+        :param out_path: Directory where results or intermediate artifacts may be written.
+        :type out_path: pathlib.Path
+        :returns: Retrieved publication records.
+        :rtype: list[dict]
+        """
+        generated_files = []
+        for entry in tqdm(query_list):
+            all_current_works = []
+            if query_type == "topic":
+                temp_works = self._topic_query(entry, year_range)
+            elif query_type == "journal":
+                temp_works = self._journal_query(entry, year_range)
+            elif query_type == "institution":
+                temp_works = self._affiliation_query(entry, year_range)
+            else:
+                raise TypeError("Provide query_type.")
+            for res_temp_works in temp_works:
+                all_current_works.append(res_temp_works)
+            with open(
+                Path(out_path / f"works_{entry}.json"), "w", encoding="utf8"
+            ) as json_file:
+                json.dump(
+                    [x for y in all_current_works for x in y],
+                    json_file,
+                    ensure_ascii=False,
+                )
+                generated_files.append(Path(out_path / f"works_{entry}.json"))
+        return generated_files
+
+    def _topic_query(self, entry: str, year_range: tuple):
+        """Run a topic-based query against OpenAlex for a single entry.
+
+        :param entry: Topic identifier to query (topic ids start with the letter t).
+        :type entry: str
+        :param year_range: Inclusive (start_year, end_year) range for filtering publication years.
+        :type year_range: tuple[int, int]
+        :returns: Publication records matching the topic and year filter.
+        :rtype: list[dict]
+        """
+        temp_works = (
+            pyalex.Works()
+            .filter(
+                topics={"id": entry},
+                from_publication_date=f"{year_range[0]}-01-01",
+                to_publication_date=f"{year_range[1]}-12-31",
+            )
+            .paginate(per_page=200, n_max=self.n_max)
+        )
+        return temp_works
+
+    def _journal_query(self, entry: str, year_range: tuple):
+        """Run a journal-based query against OpenAlex for a single entry.
+
+        :param entry: Journal identifier to query (journal ids start with the letter s).
+        :type entry: str
+        :param year_range: Inclusive (start_year, end_year) range for filtering publication years.
+        :type year_range: tuple[int, int]
+        :returns: Publication records matching the topic and year filter.
+        :rtype: list[dict]
+        """
+        temp_works = (
+            pyalex.Works()
+            .filter(
+                primary_location={"source": {"id": entry}},
+                from_publication_date=f"{year_range[0]}-01-01",
+                to_publication_date=f"{year_range[1]}-12-31",
+            )
+            .paginate(per_page=200, n_max=self.n_max)
+        )
+        return temp_works
+
+    def _affiliation_query(self, entry: str, year_range: tuple):
+        """Run a institution-based query against OpenAlex for a single entry.
+
+        :param entry: ROR ID to query (See ror.org for search options).
+        :type entry: str
+        :param year_range: Inclusive (start_year, end_year) range for filtering publication years.
+        :type year_range: tuple[int, int]
+        :returns: Publication records matching the topic and year filter.
+        :rtype: list[dict]
+        """
+        temp_works = (
+            pyalex.Works()
+            .filter(
+                authorships={"institutions": {"ror": entry}},
+                from_publication_date=f"{year_range[0]}-01-01",
+                to_publication_date=f"{year_range[1]}-12-31",
+            )
+            .paginate(per_page=200, n_max=self.n_max)
+        )
+        return temp_works

collabnet-0.1.0.dist-info/METADATA

@@ -0,0 +1,84 @@
+Metadata-Version: 2.3
+Name: collabnet
+Version: 0.1.0
+Summary: Build collaboration networks from publication records.
+Author: Malte Vogl
+Author-email: Malte Vogl <vogl@gea.mpg.de>
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Dist: pyalex
+Requires-Dist: pandas
+Requires-Dist: igraph
+Requires-Dist: tqdm
+Requires-Dist: matplotlib
+Requires-Dist: validator-collection>=1.5.0
+Requires-Python: >=3.12
+Project-URL: Bug Tracker, https://gitlab.gwdg.de/mpigea/dt/collabnet/-/issues
+Project-URL: Homepage, https://gitlab.gwdg.de/mpigea/dt/collabnet
+Project-URL: Project Homepage, https://modelsen.gea.mpg.de
+Description-Content-Type: text/markdown
+
+# CollabNet
+
+[![Documentation Status](https://readthedocs.org/projects/collabnet/badge/?version=latest)](https://collabnet.readthedocs.io/en/latest/?badge=latest)
+
+This Python package allows to generate co-authorship and co-country networks.
+The source data (currently from OpenAlex) can be works for the same journal,
+institution or topic. The data is transformed into a suitable format to facilitate
+the network creation. Networks are generated and saved as GRAPHML files.
+
+In addition the app allows to calculate the Adjusted International Collaboration Index,
+as defined in Lalli 2025.
+
+![Gephi Lite plot of Co-authorship network for 1980 with interval 3](docs/_static/gephi_lite_coauthors-1980-interval-3.png)
+
+[Gephi Lite](https://lite.gephi.org) plot of Co-authorship network for 1980 with interval 3 with 738 nodes and 2402 edges.
+Layout in ForceAtlas2 design, colors related to Louvain modularity class. Node size by degree. The selected node with label has
+degree 16.
+
+Documentation is available on [ReadTheDocs](https://collabnet.readthedocs.io).
+
+## Installation
+
+tl;dr Use pip
+
+~~~bash
+pip install collabnet
+~~~
+
+Consider using a clean virtual environment to keep your main packages separated.
+Create a new virtual environment and install the package
+
+~~~bash
+python3 -m venv env
+source env/bin/activate
+pip install collabnet
+~~~
+
+## Example
+
+You can find an example Jupyter Notebook showing the use of package by demonstrating a query for data, transforming the data, and generate networks in the [examples folder](../example/collab_pipeline.ipynb).
+
+## Testing
+
+Tests can be run by running
+
+~~~bash
+uv run pytest --cov-report=term-missing --cov=src/collabnet
+~~~
+which installs the `test` dependency group and runs the files. Coverage of testing is shown.
+
+## Building documentation
+
+The documentation is build using _sphinx_. Install of the _doc_ dependency group is automated with `uv`:
+
+~~~bash
+uv run sphinx-build -c docs -b html docs docs/_build/html
+~~~
+
+## Funding information
+
+This work is part of a collaboration between the department for
+Structural Changes of the Technosphere, Max Planck Institute of Geoanthropology, Jena, Germany and
+DIMEAS - Department of Mechanical and Aerospace Engineering, Politecnico di Torino, Torino, Italy.

collabnet-0.1.0.dist-info/RECORD

@@ -0,0 +1,7 @@
+collabnet/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+collabnet/analysis.py,sha256=4IzlcoSOA6WuO_IxukbAHrpPjSxkKaYFiaj9RV577Hw,13322
+collabnet/data.py,sha256=rWq2CGF5lHRheDtrDsjflfMpy7u-PRMEJiflTYHnPk4,9201
+collabnet/utils.py,sha256=qPL2g3YkhtASsX-fc6fgkkLBbzvDZSnzAizLKVhM-30,6598
+collabnet-0.1.0.dist-info/WHEEL,sha256=xDCZ-UyfvkGuEHPeI7BcJzYKIZzdqN8A8o1M5Om8IyA,79
+collabnet-0.1.0.dist-info/METADATA,sha256=rpmQ5vgrPfO9Z_nSSg2gbVT54Mm-_-KIj7S5KYe-WyU,3010
+collabnet-0.1.0.dist-info/RECORD,,

collabnet-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: uv 0.9.17
+Root-Is-Purelib: true
+Tag: py3-none-any