socialvec 0.2.0__py3-none-any.whl

socialvec/__init__.py

@@ -0,0 +1,5 @@
+"""Top-level package for SocialVec."""
+
+__author__ = """Nir Lotan"""
+__email__ = 'nir.lotan@gmail.com'
+__version__ = '0.2.0'

socialvec/_download.py

@@ -0,0 +1,140 @@
+"""Find, download and verify the SocialVec data files (embedding models and metadata)."""
+import hashlib
+import io
+import os
+import warnings
+from pathlib import Path
+
+import requests
+from yaspin import yaspin
+
+from .exceptions import SocialVecError
+
+PACKAGE_DIR = Path(__file__).resolve().parent
+
+_CHUNK_SIZE = 1 << 20
+# (connect, read) timeouts in seconds; the read timeout is per chunk, not for the whole file.
+_TIMEOUT = (15, 120)
+
+
+def cache_dir() -> Path:
+    """The folder downloaded files are kept in: $SOCIALVEC_HOME, or ~/.cache/socialvec."""
+    return Path(os.environ.get("SOCIALVEC_HOME") or Path.home() / ".cache" / "socialvec").expanduser()
+
+
+def _existing_locations(filename):
+    """Where the file may already be: the cache, then where versions up to 0.1.7.1 saved it."""
+    locations = []
+    for folder in (cache_dir(), PACKAGE_DIR, Path.cwd()):
+        path = folder / filename
+        if path not in locations:
+            locations.append(path)
+    return locations
+
+
+def _file_sha256(path):
+    digest = hashlib.sha256()
+    with open(path, "rb") as f:
+        for chunk in iter(lambda: f.read(_CHUNK_SIZE), b""):
+            digest.update(chunk)
+    return digest.hexdigest()
+
+
+def _download(url, out):
+    """Write the content at url to the binary file object out; return its sha256."""
+    digest = hashlib.sha256()
+    with requests.get(url, stream=True, timeout=_TIMEOUT) as response:
+        response.raise_for_status()
+        for chunk in response.iter_content(_CHUNK_SIZE):
+            out.write(chunk)
+            digest.update(chunk)
+    return digest.hexdigest()
+
+
+def _verify(actual, expected, label, url):
+    if expected and actual != expected:
+        raise SocialVecError(
+            f"The {label} downloaded from {url} is corrupted or has changed: "
+            f"expected sha256 {expected}, got {actual}.")
+
+
+def _download_error(label, url, error):
+    return SocialVecError(f"Could not download the {label} from {url}: {error}")
+
+
+def fetch(filename, url, sha256=None, label=None):
+    """
+    Get a SocialVec data file, downloading it on first use.
+
+    The file is looked up in the cache folder (see ``cache_dir``), then in the
+    package folder and the current folder, where older versions saved it.
+    If it isn't found (or its checksum doesn't match), it is downloaded to the
+    cache folder. If the cache folder can't be written, the file is downloaded
+    into memory instead.
+
+    Parameters
+    ----------
+    filename : name of the file, e.g. "SocialVec2020.pkl.gz"
+    url : where to download it from
+    sha256 : expected sha256 hex digest; the file is not used if it doesn't match
+    label : what the file is, for messages
+
+    Returns
+    -------
+    A ``pathlib.Path`` to the file, or an ``io.BytesIO`` with its contents.
+
+    Raises
+    ------
+    SocialVecError if the file can't be downloaded or doesn't match the checksum.
+
+    """
+    label = label or filename
+
+    for path in _existing_locations(filename):
+        if not path.is_file():
+            continue
+        if not sha256 or _file_sha256(path) == sha256:
+            return path
+        warnings.warn(f"Ignoring {path}: it does not match the expected checksum of the {label}.")
+
+    target = cache_dir() / filename
+    partial = target.with_name(target.name + ".part")
+    try:
+        target.parent.mkdir(parents=True, exist_ok=True)
+        with yaspin(text=f"Downloading the {label} to {target}") as spinner:
+            try:
+                with open(partial, "wb") as f:
+                    actual = _download(url, f)
+                _verify(actual, sha256, label, url)
+                os.replace(partial, target)
+            except BaseException:
+                spinner.fail("❌ ")
+                try:
+                    partial.unlink()
+                except OSError:
+                    pass
+                raise
+            spinner.ok("✅ ")
+        return target
+    except requests.RequestException as e:
+        # RequestException is an OSError too, so this must come before the OSError handler.
+        raise _download_error(label, url, e) from e
+    except OSError as e:
+        warnings.warn(
+            f"Could not save the {label} to {target.parent} ({e}); loading it into memory instead, "
+            f"so it will be downloaded again next time. Set SOCIALVEC_HOME to a writable folder to avoid this.")
+
+    buffer = io.BytesIO()
+    with yaspin(text=f"Downloading the {label} into memory") as spinner:
+        try:
+            actual = _download(url, buffer)
+            _verify(actual, sha256, label, url)
+        except requests.RequestException as e:
+            spinner.fail("❌ ")
+            raise _download_error(label, url, e) from e
+        except BaseException:
+            spinner.fail("❌ ")
+            raise
+        spinner.ok("✅ ")
+    buffer.seek(0)
+    return buffer

socialvec/api.py

@@ -0,0 +1,279 @@
+"""HTTP API for SocialVec.
+
+Run it with ``python -m socialvec.api``, or with a WSGI server, e.g.
+``gunicorn "socialvec.api:create_app()"``.
+
+Configuration (environment variables):
+
+* ``SOCIALVEC_MODEL`` - the model to load (default ``"2020"``). The classifier
+  endpoints (``/predict``, ``/predict_proba``) need ``"2020c"``.
+* ``SOCIALVEC_CORS_ORIGINS`` - comma-separated list of origins allowed to call
+  the API from a browser (default ``*``, any origin).
+* ``SOCIALVEC_HOST`` - address to listen on (default ``127.0.0.1``; use
+  ``0.0.0.0`` to accept connections from other machines).
+* ``PORT`` - port to listen on (default ``8000``).
+
+``SOCIALVEC_HOST`` and ``PORT`` only apply to ``python -m socialvec.api``.
+"""
+import logging
+import os
+
+import numpy as np
+from flask import Blueprint, Flask, current_app, jsonify, request
+from flask_cors import CORS
+from werkzeug.exceptions import HTTPException
+
+from socialvec.exceptions import InvalidUserIdError, SocialVecError, UserNotFoundError
+
+logger = logging.getLogger(__name__)
+
+DEFAULT_MODEL = "2020"
+DEFAULT_HOST = "127.0.0.1"
+DEFAULT_PORT = 8000
+DEFAULT_CORS_ORIGINS = "*"
+
+TOPN_DEFAULT = 10
+TOPN_MIN = 1
+TOPN_MAX = 100
+
+_EXTENSION_KEY = "socialvec"
+
+
+class ApiError(Exception):
+    """An error caused by the request (missing or malformed input) or by the server setup."""
+
+    def __init__(self, message, status=400):
+        super().__init__(message)
+        self.message = message
+        self.status = status
+
+
+bp = Blueprint("socialvec", __name__)
+
+
+def _state():
+    return current_app.extensions[_EXTENSION_KEY]
+
+
+def _sv():
+    return _state()["sv"]
+
+
+def _classifier():
+    state = _state()
+    if state["classifier_error"] is not None:
+        raise ApiError(state["classifier_error"], status=501)
+    return state["sv"].classifier
+
+
+def _require_arg(name):
+    value = request.args.get(name)
+    if value is None or value == "":
+        raise ApiError(f"Missing required query parameter '{name}'")
+    return value
+
+
+def _json_body():
+    data = request.get_json(silent=True)
+    if data is None:
+        data = {}
+    if not isinstance(data, dict):
+        raise ApiError("Request body must be a JSON object")
+    return data
+
+
+def _require_entity(data, name):
+    value = data.get(name)
+    if value is None or value == "" or isinstance(value, bool) or not isinstance(value, (str, int)):
+        raise ApiError(f"'{name}' is required and must be a user ID or a username")
+    return value
+
+
+def _require_classifier_name(data):
+    value = data.get("classifier_name")
+    if not isinstance(value, str) or not value:
+        raise ApiError("'classifier_name' is required and must be a string")
+    return value
+
+
+def _parse_topn():
+    raw = request.args.get("topn")
+    if raw is None or raw == "":
+        return TOPN_DEFAULT
+    try:
+        topn = int(raw)
+    except ValueError:
+        raise ApiError(f"'topn' must be an integer, got {raw!r}")
+    return max(TOPN_MIN, min(TOPN_MAX, topn))
+
+
+@bp.route('/validate_userid', methods=['GET'])
+def validate_userid():
+    result = _sv().validate_userid(_require_arg('userid'))
+    return jsonify({'userid': result})
+
+
+@bp.route('/validate_username', methods=['GET'])
+def validate_username():
+    result = _sv().validate_username(_require_arg('username'))
+    return jsonify({'userid': result})
+
+
+@bp.route('/get_screen_name', methods=['GET'])
+def get_screen_name():
+    result = _sv().get_screen_name(_require_arg('userid'))
+    return jsonify({'screen_name': result})
+
+
+@bp.route('/get_userid', methods=['GET'])
+def get_userid():
+    result = _sv().get_userid(_require_arg('username'))
+    return jsonify({'userid': result})
+
+
+@bp.route('/get_similar', methods=['GET'])
+def get_similar():
+    input_val = _require_arg('input')
+    topn = _parse_topn()
+    df = _sv().get_similar(input_val, topn)
+    return current_app.response_class(df.to_json(orient='records'), mimetype='application/json')
+
+
+@bp.route('/get_embeddings', methods=['GET'])
+def get_embeddings():
+    emb = _sv().get_embeddings(_require_arg('entity'))
+    return jsonify({'embeddings': np.asarray(emb).tolist()})
+
+
+@bp.route('/get_average_embeddings', methods=['POST'])
+def get_average_embeddings():
+    data = _json_body()
+    entity_list = data.get('entity_list')
+    if not isinstance(entity_list, list):
+        raise ApiError("'entity_list' is required and must be a list of user IDs")
+    avg_emb, count = _sv().get_average_embeddings(entity_list)
+    return jsonify({'average_embeddings': np.asarray(avg_emb).tolist(), 'count': int(count)})
+
+
+@bp.route('/get_similarity', methods=['GET'])
+def get_similarity():
+    sim = _sv().get_similarity(_require_arg('entity1'), _require_arg('entity2'))
+    return jsonify({'similarity': float(sim)})
+
+
+@bp.route('/predict', methods=['POST'])
+def predict():
+    data = _json_body()
+    classifier_name = _require_classifier_name(data)
+    entity = _require_entity(data, 'entity')
+    classifier = _classifier()
+    emb = _sv().get_embeddings(entity)
+    affiliation, pred_proba = classifier.predict(classifier_name, np.asarray(emb))
+    return jsonify({'affiliation': affiliation, 'confidence': float(pred_proba)})
+
+
+@bp.route('/predict_proba', methods=['POST'])
+def predict_proba():
+    data = _json_body()
+    classifier_name = _require_classifier_name(data)
+    entity = _require_entity(data, 'entity')
+    classifier = _classifier()
+    emb = _sv().get_embeddings(entity)
+    proba = classifier.predict_proba(classifier_name, np.asarray(emb))
+    return jsonify({'probability': float(proba)})
+
+
+def _error(message, status):
+    return jsonify({'error': message}), status
+
+
+@bp.app_errorhandler(ApiError)
+def _handle_api_error(e):
+    return _error(e.message, e.status)
+
+
+@bp.app_errorhandler(InvalidUserIdError)
+def _handle_invalid_userid(e):
+    return _error(str(e), 400)
+
+
+@bp.app_errorhandler(UserNotFoundError)
+def _handle_user_not_found(e):
+    return _error(str(e), 404)
+
+
+@bp.app_errorhandler(SocialVecError)
+def _handle_socialvec_error(e):
+    return _error(str(e), 400)
+
+
+@bp.app_errorhandler(HTTPException)
+def _handle_http_exception(e):
+    return _error(e.description, e.code)
+
+
+@bp.app_errorhandler(Exception)
+def _handle_unexpected(e):
+    logger.exception("Unhandled error in %s %s", request.method, request.path)
+    return _error("Internal server error", 500)
+
+
+def _init_classifier(sv):
+    """Load the classifiers once, up front. Returns an error message if they aren't available."""
+    try:
+        sv.init_classifier()
+    except SocialVecError as e:
+        logger.info("Classifier endpoints are disabled: %s", e)
+        return (f"Classifiers are not available with model '{sv.model_name}': {e} "
+                f"Start the API with SOCIALVEC_MODEL=2020c to enable them.")
+    return None
+
+
+def _cors_origins(value):
+    origins = [o.strip() for o in value.split(",") if o.strip()]
+    if not origins or origins == ["*"]:
+        return "*"
+    return origins
+
+
+def create_app(sv=None, model_name=None, cors_origins=None):
+    """
+    Create the Flask app.
+
+    Parameters
+    ----------
+    sv : an already loaded SocialVec instance. If omitted, one is created with
+         ``model_name``.
+    model_name : the model to load when ``sv`` is not given. Defaults to the
+         ``SOCIALVEC_MODEL`` environment variable, or "2020".
+    cors_origins : comma-separated allowed origins. Defaults to the
+         ``SOCIALVEC_CORS_ORIGINS`` environment variable, or "*".
+    """
+    if sv is None:
+        from socialvec.socialvec import SocialVec
+        sv = SocialVec(model_name=model_name or os.environ.get("SOCIALVEC_MODEL", DEFAULT_MODEL))
+
+    if cors_origins is None:
+        cors_origins = os.environ.get("SOCIALVEC_CORS_ORIGINS", DEFAULT_CORS_ORIGINS)
+
+    app = Flask(__name__)
+    CORS(app, origins=_cors_origins(cors_origins))
+    app.extensions[_EXTENSION_KEY] = {
+        "sv": sv,
+        # Loaded here, before any request is served, so requests never race to initialize it.
+        "classifier_error": _init_classifier(sv),
+    }
+    app.register_blueprint(bp)
+    return app
+
+
+def main():
+    logging.basicConfig(level=logging.INFO)
+    host = os.environ.get("SOCIALVEC_HOST", DEFAULT_HOST)
+    port = int(os.environ.get("PORT", DEFAULT_PORT))
+    app = create_app()
+    app.run(host=host, port=port)
+
+
+if __name__ == '__main__':
+    main()

socialvec/cli.py

@@ -0,0 +1,88 @@
+"""Console script for socialvec."""
+import sys
+
+import click
+
+from socialvec import __version__
+from socialvec.exceptions import SocialVecError
+
+DEFAULT_MODEL = "2020"
+CLASSIFIER_MODEL = "2020c"
+
+
+def _load(model_name):
+    # Imported here so `socialvec --help` stays fast.
+    from socialvec.socialvec import SocialVec
+    return SocialVec(model_name=model_name)
+
+
+def _model_option(default):
+    return click.option("--model", "model_name", default=default, show_default=True,
+                        help="SocialVec model to use.")
+
+
+@click.group(context_settings={"help_option_names": ["-h", "--help"]})
+@click.version_option(__version__, prog_name="socialvec")
+def main():
+    """SocialVec: social embeddings of popular Twitter accounts."""
+
+
+@main.command()
+@click.argument("user")
+@click.option("--topn", "-n", default=10, show_default=True, type=click.IntRange(1, 1000),
+              help="Number of similar accounts to show.")
+@_model_option(DEFAULT_MODEL)
+def similar(user, topn, model_name):
+    """Show the accounts most similar to USER (a user ID or username)."""
+    sv = _load(model_name)
+    df = sv.get_similar(user, topn)
+    click.echo(df[["twitter_id", "similarity", "screen_name", "name"]].to_string(index=False))
+
+
+@main.command()
+@click.argument("user1")
+@click.argument("user2")
+@_model_option(DEFAULT_MODEL)
+def similarity(user1, user2, model_name):
+    """Show the cosine similarity between USER1 and USER2."""
+    sv = _load(model_name)
+    click.echo(f"{sv.get_similarity(user1, user2):.4f}")
+
+
+@main.command()
+@click.argument("classifier")
+@click.argument("user")
+@_model_option(CLASSIFIER_MODEL)
+def predict(classifier, user, model_name):
+    """Predict a trait of USER with CLASSIFIER (e.g. political, gender, age)."""
+    sv = _load(model_name)
+    sv.init_classifier()
+    label, confidence = sv.classifier.predict(classifier, sv[user])
+    click.echo(f"{label}\t(confidence {confidence:.3f})")
+
+
+@main.command()
+@_model_option(DEFAULT_MODEL)
+def download(model_name):
+    """Download a model and the account metadata ahead of time."""
+    _load(model_name)
+    click.echo(f"Model {model_name} is ready.")
+
+
+def run():
+    """Entry point: show SocialVec errors as a message instead of a traceback."""
+    try:
+        return main(standalone_mode=False)
+    except click.exceptions.Abort:
+        click.echo("Aborted!", err=True)
+        return 1
+    except click.ClickException as e:
+        e.show()
+        return e.exit_code
+    except SocialVecError as e:
+        click.echo(f"Error: {e}", err=True)
+        return 1
+
+
+if __name__ == "__main__":
+    sys.exit(run())  # pragma: no cover

socialvec/config.yaml

@@ -0,0 +1,48 @@
+models:
+    - name: "2020"
+      filename: SocialVec2020.pkl.gz
+      download_url: https://www.dropbox.com/s/lti8npc8r2l4wch/SocialVec2020.pkl.gz?dl=1
+      sha256: 7a820239ced548010c4da0354f662feca1b1388a224ff3a672834d85dc2167ad
+    - name: "2020c"
+      filename: SocialVec2020c.pkl.gz
+      download_url: https://www.dropbox.com/scl/fi/1s1kay2z4a430lkz1erjn/SocialVec2020c.pkl.gz?rlkey=fcfbb83gkdb80ghivzt62ljmk&dl=1
+      sha256: 979c5b55fc2197a001a1cc538bbd185ab40cf9257b68f6170f4a145caa12f645
+    - name: "2020_2022"
+      filename: SocialVec2020_2022.pkl.gz
+      download_url: https://www.dropbox.com/s/5s9mykbwe0nxir6/SocialVec2020_2022.pkl.gz?dl=1
+      sha256: 7719b179778feb1d9c781ac0608413fb07638a9e95a2beea9bdabf560032181a
+metadata:
+    filename: metadata.parquet.gz
+    download_url: https://www.dropbox.com/s/060xprg4emblqwu/metadata.parquet.gz?dl=1
+    sha256: ffd6d9143b3665072d9862ca232f05ef21a2198f58522cfb37b918e77fc91902
+classification_models:
+  - name: "2020c"
+    classifiers:
+      - name: "political"
+        filename: "models/SocialVec_political_2022.h5"
+        class0: Republican
+        class1: Democrat
+      - name: "gender"
+        filename: "models/SocialVec_gender_2022.h5"
+        class0: Male
+        class1: Female
+      - name: "children"
+        filename: "models/SocialVec_children_2022.h5"
+        class0: "Yes"
+        class1: "No"
+      - name: "age"
+        filename: "models/SocialVec_age_2022.h5"
+        class0: Under25
+        class1: Over25
+      - name: "education"
+        filename: "models/SocialVec_education_2022.h5"
+        class0: Degree
+        class1: HighSchool
+      - name: "income"
+        filename: "models/SocialVec_income_2022.h5"
+        class0: High
+        class1: Low
+      - name: "ethnicity"
+        filename: "models/SocialVec_ethnicity_2022.h5"
+        class0: Caucasian
+        class1: AfrAmerican

socialvec/exceptions.py

@@ -0,0 +1,21 @@
+"""Exceptions raised by SocialVec."""
+
+
+class SocialVecError(Exception):
+    """Base class for all SocialVec errors."""
+
+
+class InvalidUserIdError(SocialVecError, ValueError):
+    """The value given is not a valid Twitter user ID or username."""
+
+
+class UserNotFoundError(SocialVecError, KeyError):
+    """The user is not in the loaded SocialVec model (or its metadata)."""
+
+    def __str__(self):
+        # KeyError wraps its message in quotes; show it like a normal error.
+        return str(self.args[0]) if self.args else ""
+
+
+class UnknownModelError(SocialVecError, ValueError):
+    """The requested SocialVec model name is not in the configuration."""

socialvec/socialvec.py

@@ -0,0 +1,409 @@
+"""Main module."""
+import gzip
+import numbers
+import os
+import pickle
+
+import numpy as np
+import pandas as pd
+import yaml
+from sklearn.metrics.pairwise import cosine_similarity
+from yaspin import yaspin
+
+from ._download import fetch
+from .exceptions import SocialVecError, InvalidUserIdError, UnknownModelError, UserNotFoundError
+
+# TensorFlow is only needed by SocialVecClassifier, which imports it when it is created,
+# so the embeddings can be used without TensorFlow installed.
+
+
+def _read_config():
+    with open(os.path.join(os.path.dirname(__file__), "config.yaml"), 'r') as f:
+        return yaml.safe_load(f)
+
+
+class SocialVec():
+    def __init__(self, model_name="2020"):
+
+        self.config = _read_config()
+
+        entry = next((m for m in self.config['models'] if m['name'] == model_name), None)
+        if entry is None:
+            available = [m['name'] for m in self.config['models']]
+            raise UnknownModelError(f"Unknown SocialVec model {model_name!r}; available models: {available}")
+        self.model_name = model_name
+
+        model_file = fetch(entry['filename'], entry['download_url'], entry.get('sha256'),
+                           label=f"SocialVec {model_name} model")
+        with yaspin(text="Initializing Model") as spinner:
+            with gzip.open(model_file, 'rb') as pickle_file:
+                self.sv = pickle.load(pickle_file)
+            spinner.ok("✅ ")
+
+        metadata = self.config['metadata']
+        metadata_file = fetch(metadata['filename'], metadata['download_url'], metadata.get('sha256'),
+                              label="SocialVec metadata")
+        with yaspin(text="Load Metadata") as spinner:
+            self.entities = pd.read_parquet(metadata_file, engine="fastparquet")
+            spinner.ok("✅ ")
+
+        self._build_lookup_tables()
+
+    def _build_lookup_tables(self):
+        """
+        Build the username -> ID and ID -> screen name lookups once, at load time.
+
+        A screen name can appear on more than one account (case-insensitively).
+        Accounts that are in the loaded model are preferred, so a lookup by name
+        finds the account that actually has an embedding.
+        """
+        ids = self.entities['twitter_id'].astype(str)
+        names = self.entities['screen_name'].astype(str)
+        in_model = ids.isin(self.sv.wv.key_to_index)
+
+        names_df = pd.DataFrame({'name': names.str.lower(), 'twitter_id': ids, 'in_model': in_model})
+        names_df = names_df.sort_values('in_model', ascending=False, kind='stable')
+        names_df = names_df.drop_duplicates('name', keep='first')
+        self._name_to_id = dict(zip(names_df['name'], names_df['twitter_id']))
+
+        id_df = pd.DataFrame({'twitter_id': ids, 'screen_name': self.entities['screen_name']})
+        id_df = id_df.drop_duplicates('twitter_id', keep='first')
+        self._id_to_screen_name = dict(zip(id_df['twitter_id'], id_df['screen_name']))
+
+    @staticmethod
+    def _is_userid_like(value) -> bool:
+        """True for ints (including numpy ints) and strings made only of digits."""
+        if isinstance(value, bool):
+            return False
+        return isinstance(value, numbers.Integral) or (isinstance(value, str) and value.isdigit())
+
+    @staticmethod
+    def _normalize_userid(userid) -> str:
+        """Convert an int / numpy int / digit string to the string ID used by the model."""
+        if isinstance(userid, bool) or userid is None:
+            raise InvalidUserIdError(f"Invalid user id: {userid!r}")
+        if isinstance(userid, numbers.Integral):
+            return str(int(userid))
+        if isinstance(userid, str) and userid.isdigit():
+            return userid
+        raise InvalidUserIdError(
+            f"User id must be an integer or a string with integer value, got {userid!r}")
+
+    def _resolve(self, entity) -> str:
+        """Resolve a user ID or a username to a user ID that is in the model."""
+        if self._is_userid_like(entity):
+            return self.validate_userid(entity)
+        if isinstance(entity, str):
+            return self.validate_username(entity)
+        raise InvalidUserIdError(f"Expected a user ID or a username, got {entity!r}")
+
+    def validate_userid(self, userid) -> str:
+        """
+        Validate the requested user ID and convert it to a string if needed.
+
+        Parameters
+        ----------
+        userid : Twitter user ID, as an int (including numpy ints) or a string of digits
+
+        Returns
+        -------
+        The user ID as a string.
+
+        Raises
+        ------
+        InvalidUserIdError if the value is not a user ID,
+        UserNotFoundError if the user is not in the loaded model.
+
+        """
+        userid = self._normalize_userid(userid)
+
+        if userid not in self.sv.wv.key_to_index:
+            raise UserNotFoundError(f"User {userid} not in SocialVec model {self.model_name}")
+
+        return userid
+
+    def validate_username(self, username) -> str:
+        """
+        Look up a username (case-insensitive) and return its user ID.
+
+        Parameters
+        ----------
+        username : Twitter screen name, e.g. "jack"
+
+        Returns
+        -------
+        The user ID (string) of an account with that name that is in the loaded model.
+
+        Raises
+        ------
+        InvalidUserIdError if username is not a string,
+        UserNotFoundError if no account with that name is in the loaded model.
+
+        """
+        userid = self.get_userid(username)
+        if userid not in self.sv.wv.key_to_index:
+            raise UserNotFoundError(
+                f"User '{username}' is in the SocialVec metadata but not in model {self.model_name}")
+        return userid
+
+    def get_screen_name(self, userid):
+        """
+        Get the screen name for a given user ID.
+
+        Parameters
+        ----------
+        userid : string or int representing the Twitter user ID
+
+        Returns
+        -------
+        The Twitter screen name, or None if the user is in the model but has no metadata.
+
+        Raises
+        ------
+        InvalidUserIdError / UserNotFoundError, as in validate_userid.
+
+        """
+        userid = self.validate_userid(userid)
+        return self._id_to_screen_name.get(userid)
+
+    def get_userid(self, username: str) -> str:
+        """
+        Get the user ID for a given screen name (case-insensitive).
+
+        If several accounts share the name, an account that is in the loaded
+        model is preferred. The returned account may still be one that only
+        exists in the metadata; use validate_username to require an embedding.
+
+        Parameters
+        ----------
+        username : Twitter screen name
+
+        Returns
+        -------
+        The Twitter user ID as a string.
+
+        Raises
+        ------
+        InvalidUserIdError if username is not a string,
+        UserNotFoundError if the name is not in the SocialVec metadata.
+
+        """
+        if not isinstance(username, str):
+            raise InvalidUserIdError(f"Username must be a string, got {username!r}")
+        userid = self._name_to_id.get(username.lower())
+        if userid is None:
+            raise UserNotFoundError(f"User '{username}' not in SocialVec metadata")
+        return userid
+
+    def get_similar(self, input, topn: int = 10):
+        """
+        This function returns the topn similar entities for a given entity
+
+        Parameters
+        ----------
+        input : a user ID, a username, an embedding vector, or a list of user IDs / usernames (whose embeddings are averaged)
+        topn : requested number of similar entities
+
+        Returns
+        -------
+        Pandas dataframe with the top n similar entities details
+
+        """
+
+        if isinstance(input, (list, tuple)):
+            input = [item if isinstance(item, np.ndarray) else self._resolve(item) for item in input]
+        elif not isinstance(input, np.ndarray):
+            input = self._resolve(input)
+
+        sim = self.sv.wv.most_similar(input, topn=topn)
+        similar = pd.DataFrame(sim, columns=['twitter_id', 'similarity'])
+        return pd.merge(similar, self.entities, on='twitter_id', how='left')
+
+    def __getitem__(self, key):
+        """
+        Overload [] operator to return the entity embeddings
+
+        Parameters
+        ----------
+        key - integer, string with user ID or string with username
+
+        Returns
+        -------
+        SocialVec embeddings vector of the popular entity
+
+        """
+        return self.sv.wv[self._resolve(key)]
+
+    def get_embeddings(self, entity):
+        """
+        This function is a different way to trigger the [] operator
+        """
+        return self[entity]
+
+    def get_average_embeddings(self, entity_list, type=""):
+        """
+        This function returns the average embeddings for a given list of Twitter user IDs
+
+        Parameters
+        ----------
+        entity_list - list of entities IDs
+        type - will be extended for future use with usernames
+
+        Returns
+        -------
+        A tuple of the (1) average vector (2) the number of popular entities on which it was based.
+        IDs that are not in the model are skipped; if none are left, the vector is all zeros.
+
+        """
+
+        popular_entities = []
+        for entity in entity_list:
+            try:
+                popular_entities.append(self.validate_userid(entity))
+            except SocialVecError:
+                continue
+
+        if len(popular_entities) != 0:
+            sv = np.mean(self.sv.wv[popular_entities], axis=0)
+        else:
+            sv = np.zeros(self.sv.wv.vector_size, dtype=np.float32)
+
+        return sv, len(popular_entities)
+
+    def get_similarity(self, entity1, entity2):
+        """
+        This function returns the similarity between two entities
+
+        Parameters
+        ----------
+        entity1 - first entity ID
+        entity2 - second entity ID
+
+        Returns
+        -------
+        The cosine similarity score between the two entities
+
+        """
+
+        if type(entity1)==np.ndarray:
+            v1 = entity1
+        else:
+            v1 = self[entity1]
+        if type(entity2) == np.ndarray:
+            v2 = entity2
+        else:
+            v2 = self[entity2]
+
+        return cosine_similarity(v1.reshape(1, -1),v2.reshape(1, -1))[0][0]
+
+    def init_classifier(self):
+        self.classifier = self.SocialVecClassifier(self.model_name)
+
+    class SocialVecClassifier():
+        def __init__(self, model_name):
+
+            current_folder = os.path.dirname(__file__)
+            self.config = _read_config()
+
+            # Classifiers are trained on one model's embedding space and can't be used with another
+            entry = next((m for m in self.config['classification_models'] if m['name'] == model_name), None)
+            if entry is None:
+                available = [m['name'] for m in self.config['classification_models']]
+                raise SocialVecError(
+                    f"No classifiers are available for model '{model_name}'. "
+                    f"Classifiers exist for: {available}, e.g. SocialVec(model_name='{available[0]}')")
+
+            try:
+                import tensorflow as tf
+                from tensorflow import keras
+            except ImportError as e:
+                raise SocialVecError(
+                    "The SocialVec classifiers need TensorFlow, which could not be imported "
+                    f"({e}). Install it with: pip install 'socialvec[classifier]'") from e
+            self._tf = tf
+
+            keras.utils.get_custom_objects().update({'recall_m': self.recall_m,
+                                                     'precision_m': self.precision_m,
+                                                     'f1_m': self.f1_m})
+
+            self.models_dict = {}
+            self.models_classes = {}
+
+            for classifier in entry['classifiers']:
+                classifier_name = classifier['name']
+                classifier_path = os.path.join(current_folder, classifier['filename'])
+                if not os.path.exists(classifier_path):
+                    raise SocialVecError(
+                        f"Configuration error: classifier {classifier_name} not found at {classifier_path}")
+                self.models_dict[classifier_name] = keras.models.load_model(classifier_path)
+                self.models_classes[classifier_name] = {'class0': classifier['class0'],
+                                                        'class1': classifier['class1']}
+
+        @property
+        def classifier_names(self):
+            return list(self.models_dict)
+
+        def _raw_predict(self, classifier_name, v):
+            if classifier_name not in self.models_dict:
+                raise SocialVecError(
+                    f"Unknown classifier {classifier_name!r}; available: {self.classifier_names}")
+            model = self.models_dict[classifier_name]
+            param_to_predict = self._tf.convert_to_tensor(np.asarray(v, dtype=np.float32).reshape(1, -1))
+            return model.predict(param_to_predict, verbose=False)[0][0]
+
+        def predict_proba(self, classifier_name, v):
+            """
+            Return the confidence of the prediction, between 0 and 1.
+
+            Despite the name, this is not the probability of a specific class:
+            it is abs(p - 0.5) * 2 for the classifier's raw output p, i.e. 1 when the
+            classifier is certain of either class and 0 when it can't tell them apart.
+            Use predict() to also get which class was predicted.
+            """
+            return abs(self._raw_predict(classifier_name, v) - 0.5)*2
+
+        def predict(self, classifier_name, v):
+            """
+            Classify an embedding vector.
+
+            Returns
+            -------
+            A tuple (class label, confidence between 0 and 1); see predict_proba for the confidence.
+            """
+            prediction = self._raw_predict(classifier_name, v)
+
+            # Original prediction is 0 for Democrat, 1 for Republican.
+            # We convert it here to a confidence interval between 0 to 1 for either of the classes
+            pred_proba = abs(prediction - 0.5)*2
+
+            if round(prediction):
+                affiliation =  self.models_classes[classifier_name]['class0']
+            else:
+                affiliation =  self.models_classes[classifier_name]['class1']
+
+            return (affiliation, pred_proba)
+
+        # Custom metrics the classifiers were saved with; Keras needs them to load the .h5 files.
+
+        @staticmethod
+        def recall_m(y_true, y_pred):
+            from tensorflow.keras import backend as K
+            true_positives = K.sum(K.round(K.clip(y_true * y_pred, 0, 1)))
+            possible_positives = K.sum(K.round(K.clip(y_true, 0, 1)))
+            recall = true_positives / (possible_positives + K.epsilon())
+            return recall
+
+        @staticmethod
+        def precision_m(y_true, y_pred):
+            from tensorflow.keras import backend as K
+            true_positives = K.sum(K.round(K.clip(y_true * y_pred, 0, 1)))
+            predicted_positives = K.sum(K.round(K.clip(y_pred, 0, 1)))
+            precision = true_positives / (predicted_positives + K.epsilon())
+            return precision
+
+        @staticmethod
+        def f1_m(y_true, y_pred):
+            from tensorflow.keras import backend as K
+            precision = SocialVec.SocialVecClassifier.precision_m(y_true, y_pred)
+            recall = SocialVec.SocialVecClassifier.recall_m(y_true, y_pred)
+            return 2*((precision*recall)/(precision+recall+K.epsilon()))

socialvec-0.2.0.dist-info/METADATA

@@ -0,0 +1,275 @@
+Metadata-Version: 2.4
+Name: socialvec
+Version: 0.2.0
+Summary: Pre-trained social embeddings of popular Twitter accounts, for eliciting social world knowledge.
+Home-page: https://github.com/nirlotan/SocialVec
+Author: Nir Lotan
+Author-email: nir.lotan@gmail.com
+License: MIT
+Project-URL: Paper, https://doi.org/10.1371/journal.pone.0283700
+Project-URL: Source, https://github.com/nirlotan/SocialVec
+Project-URL: Issues, https://github.com/nirlotan/SocialVec/issues
+Project-URL: Changelog, https://github.com/nirlotan/SocialVec/blob/master/HISTORY.rst
+Keywords: socialvec,embeddings,social network,twitter,knowledge,word2vec
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: Natural Language :: English
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Sociology
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: click>=8.1.3
+Requires-Dist: pandas>=1.5.0
+Requires-Dist: numpy>=1.23.3
+Requires-Dist: fastparquet>=0.8.3
+Requires-Dist: pyarrow
+Requires-Dist: requests
+Requires-Dist: yaspin
+Requires-Dist: PyYAML
+Requires-Dist: gensim>4
+Requires-Dist: scikit-learn
+Provides-Extra: classifier
+Requires-Dist: tensorflow; extra == "classifier"
+Provides-Extra: api
+Requires-Dist: flask; extra == "api"
+Requires-Dist: flask-cors; extra == "api"
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: license
+Dynamic: license-file
+Dynamic: project-url
+Dynamic: provides-extra
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# SocialVec
+
+[![PyPI](https://img.shields.io/pypi/v/socialvec.svg)](https://pypi.org/project/socialvec/)
+[![Python versions](https://img.shields.io/pypi/pyversions/socialvec.svg)](https://pypi.org/project/socialvec/)
+[![Tests](https://github.com/nirlotan/SocialVec/actions/workflows/tests.yml/badge.svg)](https://github.com/nirlotan/SocialVec/actions/workflows/tests.yml)
+[![License: MIT](https://img.shields.io/badge/license-MIT-blue.svg)](https://github.com/nirlotan/SocialVec/blob/master/LICENSE)
+
+**SocialVec** provides pre-trained *social embeddings* for about 200,000 popular Twitter accounts, learned from the follow graph of 1.3 million users. Accounts that are often followed by the same people end up close together, the same way words that appear in similar contexts do in word embeddings. The result captures *social world knowledge*: how people relate to entities, rather than facts about them.
+
+SocialVec was developed by Nir Lotan and Einat Minkov. See the paper: [Social world knowledge: Modeling and applications](https://journals.plos.org/plosone/article?id=10.1371/journal.pone.0283700) (PLOS ONE, 2023).
+
+With this package you can:
+
+- get the 100-dimensional embedding of a popular account, by user ID or username;
+- find similar accounts, for one account, a group of accounts, or any vector;
+- represent any user as the average embedding of the accounts they follow;
+- predict personal traits (political leaning, gender, age, and more) from an embedding;
+- serve all of the above over a small HTTP API, or use it from the command line.
+
+## Installation
+
+```bash
+pip install socialvec
+```
+
+The classifiers need TensorFlow and the HTTP API needs Flask. Both are optional extras:
+
+```bash
+pip install "socialvec[classifier]"        # adds TensorFlow
+pip install "socialvec[api]"               # adds Flask and flask-cors
+pip install "socialvec[classifier,api]"    # both
+```
+
+SocialVec supports Python 3.10 to 3.13.
+
+## Quick start
+
+```python
+from socialvec.socialvec import SocialVec
+
+sv = SocialVec()                    # downloads the model on first use, see "Models and data"
+sv.get_similar("jack", topn=5)
+```
+
+```
+  twitter_id  similarity   screen_name           name  description
+0    6385432    0.841613         dickc   dick costolo  ...
+1        989    0.831723            om             OM  ...
+2    5746452    0.827466  waltmossberg  Walt Mossberg  ...
+3   20536157    0.826462        Google         Google  ...
+4    6708952    0.819312     SteveCase     Steve Case  ...
+```
+
+## Usage
+
+### Embeddings
+
+An account can be given as a user ID (an `int`, including numpy integers, or a string of digits) or as a username (case-insensitive):
+
+```python
+sv[12]                    # the same 100-dimensional vector, three ways
+sv["12"]
+sv["jack"]
+
+sv.get_userid("NASA")       # '11348282'
+sv.get_screen_name(813286)  # 'BarackObama'
+```
+
+### Similar accounts
+
+`get_similar` takes a user ID, a username, a vector, or a list of IDs and usernames (whose embeddings are averaged). It returns a pandas DataFrame with the `topn` most similar accounts and their metadata.
+
+```python
+sv.get_similar(["Harvard", "MIT", "UCLA"], topn=5)
+```
+
+```
+  twitter_id  similarity      screen_name                  name
+0    5695032    0.867065             Yale       Yale University
+1    5694822    0.861724        Princeton  Princeton University
+2  248795646    0.850461         Columbia   Columbia University
+3   14884486    0.845595  BrownUniversity      Brown University
+4   33474655    0.840983    Cambridge_Uni  Cambridge University
+```
+
+```python
+sv.get_similar(["FCBarcelona", "ManUtd", "realmadrid"], topn=5)
+```
+
+```
+  twitter_id  similarity     screen_name              name
+0  740336334    0.931517    GarethBale11       Gareth Bale
+1  344801362    0.917337     DavidLuiz_4        David Luiz
+2  140750163    0.915364       juanmata8  Juan Mata García
+3  112764971    0.913976  FCBarcelona_es      FC Barcelona
+4  533085085    0.912526             M10        Mesut Özil
+```
+
+### Similarity between two accounts
+
+```python
+sv.get_similarity("BarackObama", "HillaryClinton")    # 0.755
+sv.get_similarity("BarackObama", "realDonaldTrump")   # 0.613
+```
+
+Either argument can also be a vector.
+
+### Embedding any user
+
+Most users aren't popular enough to have their own embedding. You can represent them by the average embedding of the accounts they follow. `get_average_embeddings` takes a list of user IDs and returns the average vector and the number of accounts it was based on. IDs that aren't in the model are skipped; if none are left, the vector is all zeros and the count is 0.
+
+```python
+following = [12, 989, 783214]           # e.g. the IDs a user follows, from the Twitter/X API
+vector, count = sv.get_average_embeddings(following)
+sv.get_similar(vector, topn=5)
+```
+
+### Classifiers
+
+The classifiers predict personal traits from an embedding. They need the `classifier` extra (TensorFlow) and the `"2020c"` model they were trained on; calling `init_classifier()` on another model raises an error.
+
+```python
+sv = SocialVec(model_name="2020c")
+sv.init_classifier()
+
+sv.classifier.predict("political", sv["JoeBiden"])          # ('Democrat', 0.989)
+sv.classifier.predict("political", sv["realDonaldTrump"])   # ('Republican', 0.866)
+```
+
+`predict` returns the predicted class and a confidence between 0 and 1, where 1 is high confidence and 0 is no confidence (which may be expected for accounts with no affiliation, e.g. a non-political account and the `political` classifier). To classify an ordinary user, pass the vector from `get_average_embeddings`.
+
+| Classifier | Classes |
+|---|---|
+| `political` | Republican / Democrat |
+| `gender` | Male / Female |
+| `children` | Yes / No |
+| `age` | Under25 / Over25 |
+| `education` | Degree / HighSchool |
+| `income` | High / Low |
+| `ethnicity` | Caucasian / AfrAmerican |
+
+`sv.classifier.classifier_names` lists them.
+
+### Errors
+
+Lookups raise `socialvec.exceptions.InvalidUserIdError` (a `ValueError`) for values that aren't a user ID or username, and `socialvec.exceptions.UserNotFoundError` (a `KeyError`) for accounts that aren't in the loaded model. An unknown `model_name` raises `UnknownModelError` (a `ValueError`), and a failed download raises `SocialVecError`. All of them subclass `socialvec.exceptions.SocialVecError`.
+
+## Models and data
+
+| `model_name` | Notes |
+|---|---|
+| `"2020"` | Default. |
+| `"2020c"` | The model the classifiers were trained on. |
+| `"2020_2022"` | |
+
+On first use, SocialVec downloads the model (about 150 MB, or 300 MB for `"2020_2022"`) and the account metadata (about 30 MB). Later runs load them from disk.
+
+- Files are kept in `~/.cache/socialvec`. To keep them somewhere else, set the `SOCIALVEC_HOME` environment variable to a folder.
+- Files that versions up to 0.1.7.1 saved in the package folder or the working folder are still found and used.
+- Every file is checked against a SHA-256 checksum before it is loaded.
+- If the cache folder can't be written, the model is loaded into memory instead (and downloaded again next time).
+
+## Command line
+
+```bash
+socialvec similar jack --topn 5
+socialvec similarity BarackObama HillaryClinton
+socialvec predict political JoeBiden          # uses the 2020c model; needs the classifier extra
+socialvec download --model 2020c              # fetch a model ahead of time
+```
+
+`socialvec --help` lists all options. Every command takes `--model` to choose the model.
+
+## HTTP API
+
+SocialVec includes a small Flask API (install the `api` extra):
+
+```bash
+SOCIALVEC_MODEL=2020c python -m socialvec.api
+```
+
+It can also run under a WSGI server, e.g. `gunicorn "socialvec.api:create_app()"`. Importing `socialvec.api` does not load a model; `create_app()` does.
+
+| Variable | Default | Meaning |
+|---|---|---|
+| `SOCIALVEC_MODEL` | `2020` | Model to load. `/predict` and `/predict_proba` need `2020c`; with other models they return 501. |
+| `SOCIALVEC_CORS_ORIGINS` | `*` | Comma-separated origins allowed to call the API from a browser. |
+| `SOCIALVEC_HOST` | `127.0.0.1` | Address to listen on. Use `0.0.0.0` to accept connections from other machines. |
+| `PORT` | `8000` | Port to listen on. |
+
+Endpoints:
+
+- `GET /validate_userid?userid=`, `/validate_username?username=`, `/get_screen_name?userid=`, `/get_userid?username=`
+- `GET /get_similar?input=&topn=` (`topn` is clamped to 1–100), `/get_embeddings?entity=`, `/get_similarity?entity1=&entity2=`
+- `POST` with a JSON body: `/get_average_embeddings` `{"entity_list": [...]}`, `/predict` and `/predict_proba` `{"classifier_name": "political", "entity": "jack"}`
+
+Errors are returned as `{"error": "..."}` with status 400 for bad input, 404 for accounts not in the model, and 500 (with no details) for unexpected errors, which are logged.
+
+## Citation
+
+If you use SocialVec in your research, please cite:
+
+```bibtex
+@article{lotan2023social,
+  title   = {Social world knowledge: Modeling and applications},
+  author  = {Lotan, Nir and Minkov, Einat},
+  journal = {PLOS ONE},
+  volume  = {18},
+  number  = {7},
+  pages   = {e0283700},
+  year    = {2023},
+  doi     = {10.1371/journal.pone.0283700}
+}
+```
+
+## License
+
+MIT. See [LICENSE](https://github.com/nirlotan/SocialVec/blob/master/LICENSE). The changelog is in [HISTORY.rst](https://github.com/nirlotan/SocialVec/blob/master/HISTORY.rst).

socialvec-0.2.0.dist-info/RECORD

@@ -0,0 +1,20 @@
+socialvec/__init__.py,sha256=7WlH3O7yS8uBKs9Th9duhPQQgxpGKi7C5oefIVE_cCs,125
+socialvec/_download.py,sha256=5ScGUX6OI8gXaxPeJI5oUmtwTDMUhHXG5F0c_MEcs9Y,4844
+socialvec/api.py,sha256=qbEXXheZgKws5c4LJeFYsQ9nTrLZl7Jmt6lEz9KQ8k8,8311
+socialvec/cli.py,sha256=IjWqdWuNTbjT-pPrtQvbS8LuIEz4b-NLWf6dywuLipA,2624
+socialvec/config.yaml,sha256=RDscPseGIfXzsYp3znMsofIcbdUgbdXHn1pfAIWyOsA,1873
+socialvec/exceptions.py,sha256=MjXirsjVzQz6eQKxhjs3RNEJofT-KRw3AAr0355DmC0,658
+socialvec/socialvec.py,sha256=5RSd89mCZqMp-YIl10vAbge2SLGzng3EVppV5dufAno,15549
+socialvec/models/SocialVec_age_2022.h5,sha256=Q9nmHTiSbN0kGCGlNE8nan0wmYbFBrmJnVJ4fMwR1M8,22576
+socialvec/models/SocialVec_children_2022.h5,sha256=Og6sYI1PqEa6q_WyZkrMgouKOmhelFq0ypagOKGilkE,22576
+socialvec/models/SocialVec_education_2022.h5,sha256=CmV3L6dVTMICAE5ebCY04D_iBecmksp2PyZv1Hltpy8,22576
+socialvec/models/SocialVec_ethnicity_2022.h5,sha256=BfwOlLFiUgyZa4vaqfCKZstKvRnyXh8HRcA4jF8Jpn4,22576
+socialvec/models/SocialVec_gender_2022.h5,sha256=v-d8tDQ5aJ3uhRFxTmv4wJdtNt4xH5hemiWGkY6iNEs,22576
+socialvec/models/SocialVec_income_2022.h5,sha256=IbFbacYa-pNfyG_i_dhZF_5GlhC05Xp96tzESiq8qZw,22576
+socialvec/models/SocialVec_political_2022.h5,sha256=a61UoZNQtvA2MXbMoAFmWwejh7MjpZ5tdNpUXcFfaLw,22576
+socialvec-0.2.0.dist-info/licenses/LICENSE,sha256=pSpIOtPcWehxx0T4p-Y_1aukVbqwC7M6ElF5akGXl5o,1068
+socialvec-0.2.0.dist-info/METADATA,sha256=Ck87Aa7QcG-z8imlriZGt3X-MlNI-UUCfLEt6fil9cQ,11283
+socialvec-0.2.0.dist-info/WHEEL,sha256=mOdXR9C3wMVov7cSY8PY-XCzo3SmmWCHvGQr5csJoao,91
+socialvec-0.2.0.dist-info/entry_points.txt,sha256=wo0aeBs8HWfqw-ecAOzOu3PVHG2-qfmA4A3u6M2LWO4,48
+socialvec-0.2.0.dist-info/top_level.txt,sha256=s06aCPWn0lMnLKdU0vCbA7pQhD0DY69ScXnj7TYzJ7A,10
+socialvec-0.2.0.dist-info/RECORD,,

socialvec-0.2.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.2.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

socialvec-0.2.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+socialvec = socialvec.cli:run

socialvec-0.2.0.dist-info/licenses/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2022, Nir Lotan
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+

socialvec-0.2.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+socialvec