computational-sociology

name	computational-sociology
description	Computational social science methods: social media data collection, bot detection, network homophily, echo chamber analysis, and conjoint survey experiments.
tags	["sociology","social-networks","twitter","reddit","computational-social-science","survey-experiments"]
version	1.0.0
authors	[{"name":"awesome-rosetta-skills contributors","github":"@awesome-rosetta-skills"}]
license	MIT
platforms	["claude-code","codex","gemini-cli","cursor"]
dependencies	["tweepy>=4.14.0","praw>=7.7.0","vaderSentiment>=3.3.1","networkx>=3.1","pandas>=2.0.0","numpy>=1.24.0","scipy>=1.11.0","matplotlib>=3.7.0","seaborn>=0.12.0","statsmodels>=0.14.0"]
last_updated	2026-03-17

Computational Sociology

Computational social science methods for studying online behavior, social networks, political polarization, and survey-based causal inference. This skill covers data collection from major social media platforms, automated account detection, network analysis metrics, and experimental designs for measuring social preferences.

Prerequisites

pip install tweepy praw vaderSentiment networkx pandas numpy scipy \
            matplotlib seaborn statsmodels

Set the required environment variables before running any data collection:

export TWITTER_BEARER_TOKEN="<paste-your-bearer-token>"
export REDDIT_CLIENT_ID="<paste-your-client-id>"
export REDDIT_CLIENT_SECRET="<paste-your-client-secret>"
export REDDIT_USER_AGENT="ComputationalSociologyBot/1.0"

Core Functions

1. Twitter/X Academic API v2 Data Collection

import os
import time
import tweepy
import pandas as pd
from datetime import datetime, timezone


def collect_tweets(
    query: str,
    start_time: str,
    end_time: str,
    bearer_token_env: str = "TWITTER_BEARER_TOKEN",
    max_results_per_page: int = 100,
    max_total: int = 5000,
    include_fields: list[str] | None = None,
) -> pd.DataFrame:
    """
    Collect tweets from Twitter/X Academic API v2 using tweepy paginator.

    Parameters
    ----------
    query : str
        Twitter search query string (supports operators like lang:en, -is:retweet).
    start_time : str
        ISO 8601 start datetime, e.g. "2023-01-01T00:00:00Z".
    end_time : str
        ISO 8601 end datetime, e.g. "2023-12-31T23:59:59Z".
    bearer_token_env : str
        Name of the environment variable holding the bearer token.
    max_results_per_page : int
        Results per API call (10-100 for basic, up to 500 for academic).
    max_total : int
        Maximum total tweets to retrieve.
    include_fields : list[str] | None
        Extra tweet fields to request.

    Returns
    -------
    pd.DataFrame
        DataFrame with columns: id, text, created_at, author_id,
        retweet_count, like_count, reply_count, lang, possibly_sensitive.
    """
    bearer_token = os.environ.get(bearer_token_env)
      bearer_token:
         EnvironmentError(
            
            
        )

    client = tweepy.Client(
        bearer_token=bearer_token,
        wait_on_rate_limit=,
    )

    tweet_fields = [
        , , , , ,
        , , ,
        ,
    ]
     include_fields:
        tweet_fields = ((tweet_fields + include_fields))

    user_fields = [
        , , , , ,
        , , ,
    ]

    records = []
    paginator = tweepy.Paginator(
        client.search_all_tweets,
        query=query,
        start_time=start_time,
        end_time=end_time,
        tweet_fields=tweet_fields,
        user_fields=user_fields,
        expansions=[],
        max_results=max_results_per_page,
    )

    users_lookup: [, ] = {}

     response  paginator:
         response.includes    response.includes:
             u  response.includes[]:
                users_lookup[(u.)] = {
                    : u.username,
                    : u.created_at,
                    : u.public_metrics.get(, ),
                    : u.public_metrics.get(, ),
                    : u.public_metrics.get(, ),
                    : u.verified,
                }

         response.data:
             tweet  response.data:
                m = tweet.public_metrics  {}
                user_meta = users_lookup.get((tweet.author_id), {})
                records.append({
                    : (tweet.),
                    : tweet.text,
                    : tweet.created_at,
                    : (tweet.author_id),
                    : tweet.lang,
                    : m.get(, ),
                    : m.get(, ),
                    : m.get(, ),
                    : tweet.possibly_sensitive,
                    **user_meta,
                })

         (records) >= max_total:
            
        time.sleep()

    df = pd.DataFrame(records).drop_duplicates(subset=[])
    df[] = pd.to_datetime(df[], utc=)
     df.head(max_total)


 () -> pd.DataFrame:
    
     praw

    reddit = praw.Reddit(
        client_id=os.environ[],
        client_secret=os.environ[],
        user_agent=os.environ.get(, ),
    )

    records = []
     sub_name  subreddits:
        subreddit = reddit.subreddit(sub_name)
        fetcher = {
            : subreddit.new,
            : subreddit.hot,
            : subreddit.top,
            : subreddit.rising,
        }.get(sort, subreddit.new)

         post  fetcher(limit=limit_per_sub):
            records.append({
                : post.,
                : sub_name,
                : post.title,
                : post.selftext,
                : post.score,
                : post.num_comments,
                : post.upvote_ratio,
                : (post.author)  post.author  ,
                : datetime.fromtimestamp(post.created_utc, tz=timezone.utc),
                : post.url,
                : post.is_self,
            })

     pd.DataFrame(records)