threadlepy 0.1.1__tar.gz → 0.1.2__tar.gz

{threadlepy-0.1.1 → threadlepy-0.1.2}/CHANGELOG.md

@@ -1,5 +1,11 @@
 # Changelog
 
+## 0.1.2
+
+- Added one-line docstrings for public command wrappers.
+- Added `Literal` type hints for finite-choice parameters to improve editor completions.
+- Marked the package as typed with `py.typed`.
+
 ## 0.1.1
 
 - Updated PyPI project description to match README.

{threadlepy-0.1.1 → threadlepy-0.1.2}/MANIFEST.in

@@ -4,6 +4,7 @@ include CHANGELOG.md
 include pyproject.toml
 
 recursive-include src/threadlepy/Examples *.tsv *.txt
+include src/threadlepy/py.typed
 recursive-include docs *.ipynb
 recursive-include scripts *.py
 

{threadlepy-0.1.1/src/threadlepy.egg-info → threadlepy-0.1.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: threadlepy
-Version: 0.1.1
+Version: 0.1.2
 Summary: Python client for the Threadle CLI JSON interface.
 Author: Yukun Jiao
 License-Expression: MIT

{threadlepy-0.1.1 → threadlepy-0.1.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "threadlepy"
-version = "0.1.1"
+version = "0.1.2"
 description = "Python client for the Threadle CLI JSON interface."
 readme = "README.md"
 requires-python = ">=3.9"
@@ -27,4 +27,4 @@ Source = "https://github.com/YukunJiao/threadlepy"
 where = ["src"]
 
 [tool.setuptools.package-data]
-threadlepy = ["Examples/*.tsv", "Examples/Scripts/*.txt"]
+threadlepy = ["py.typed", "Examples/*.tsv", "Examples/Scripts/*.txt"]

{threadlepy-0.1.1 → threadlepy-0.1.2}/src/threadlepy/__init__.py

@@ -2,7 +2,7 @@
 
 from .client import ThreadleStruct, configure, is_available, raw_cmd, session, start, stop
 
-__version__ = "0.1.1"
+__version__ = "0.1.2"
 
 __all__ = [
     "ThreadleStruct",

{threadlepy-0.1.1 → threadlepy-0.1.2}/src/threadlepy/client.py

@@ -48,6 +48,7 @@ def configure(
         default_timeout = float(timeout)
 
 def stop():
+    """Stop the running Threadle subprocess, if one is active."""
     global proc
     if proc and proc.poll() is None:
         print("threadle stopped")
@@ -56,6 +57,7 @@ def stop():
     proc = None
 
 def start(path: str | None = None) -> subprocess.Popen[str]:
+    """Start the Threadle CLI JSON subprocess and return the process handle."""
     global proc
     if path is None or not str(path).strip():
         exe = shutil.which("threadle")
@@ -112,9 +114,11 @@ def session(path: str | None = None, **config: Any) -> Iterator[subprocess.Popen
         stop()
 
 def collect_args(**kwargs):
+    """Return keyword arguments whose values are not ``None``."""
     return {k: v for k, v in kwargs.items() if v is not None}
 
 def json_cmd(command: str, args: Optional[Dict[str, Any]] = None, assign: Optional[str] = None) -> str:
+    """Build a JSON command payload for the Threadle CLI."""
     dto = {
         "Assign": assign,
         "Command": str(command),
@@ -123,6 +127,7 @@ def json_cmd(command: str, args: Optional[Dict[str, Any]] = None, assign: Option
     return json.dumps(dto, ensure_ascii=False)
 
 def send_command(cmd_json: str, timeout: Optional[float] = None) -> Dict[str, Any]:
+    """Send a JSON command to Threadle and wait for a JSON response."""
     global proc
     if proc is None or proc.poll() is not None:
         raise RuntimeError("Threadle process is not running.")
@@ -177,6 +182,7 @@ def send_command(cmd_json: str, timeout: Optional[float] = None) -> Dict[str, An
     raise TimeoutError(hint)
 
 def unwrap(resp: Dict[str, Any], *, print_message: bool = True) -> Any:
+    """Validate a Threadle response and return its payload."""
     if resp.get("Success") is not True:
         code = resp.get("Code") or "Error"
         msg = resp.get("Message") or "Threadle error"
@@ -209,6 +215,7 @@ def call(
     return_response: bool = False,
     drop: tuple[str, ...] = (),
 ) -> Any:
+    """Call a typed Threadle command wrapper using the caller's local variables."""
     args = collect_args(**locals_dict)
     args.pop("cmd", None)
     args.pop("assign", None)

{threadlepy-0.1.1 → threadlepy-0.1.2}/src/threadlepy/commands.py

@@ -3,15 +3,33 @@ from __future__ import annotations
 import os
 import shutil
 from importlib import resources
-from typing import Any, Optional, Union
+from typing import Any, Literal, Optional, Union
 
 from .client import ThreadleName, ThreadleStruct, call, is_available as _client_is_available, raw_cmd, start, stop
 
 NodeId = Union[int, str]
-
-CONDITIONS = ("eq", "ne", "gt", "lt", "ge", "le", "isnull", "notnull")
-DIRECTIONS = ("both", "in", "out")
-ATTR_TYPES = ("int", "char", "float", "bool", "string")
+Condition = Literal["eq", "ne", "gt", "lt", "ge", "le", "isnull", "notnull"]
+NumericCondition = Literal["eq", "ne", "gt", "lt", "ge", "le"]
+Direction = Literal["both", "in", "out"]
+AttrType = Literal["int", "char", "float", "bool", "string"]
+LayerMode = Literal[1, 2, "1", "2"]
+LayerValueType = Literal["binary", "valued"]
+LayerFormat = Literal["edgelist", "matrix"]
+StructureType = Literal["network", "nodeset"]
+SymmetrizeMethod = Literal["max", "min", "minnonzero", "average", "sum", "product"]
+ProjectMethod = Literal["count", "newman", "binary"]
+GenerateType = Literal["er", "ws", "ba", "2mode"]
+
+CONDITIONS: tuple[Condition, ...] = ("eq", "ne", "gt", "lt", "ge", "le", "isnull", "notnull")
+NUMERIC_CONDITIONS: tuple[NumericCondition, ...] = ("eq", "ne", "gt", "lt", "ge", "le")
+DIRECTIONS: tuple[Direction, ...] = ("both", "in", "out")
+ATTR_TYPES: tuple[AttrType, ...] = ("int", "char", "float", "bool", "string")
+LAYER_VALUE_TYPES: tuple[LayerValueType, ...] = ("binary", "valued")
+LAYER_FORMATS: tuple[LayerFormat, ...] = ("edgelist", "matrix")
+STRUCTURE_TYPES: tuple[StructureType, ...] = ("network", "nodeset")
+SYMMETRIZE_METHODS: tuple[SymmetrizeMethod, ...] = ("max", "min", "minnonzero", "average", "sum", "product")
+PROJECT_METHODS: tuple[ProjectMethod, ...] = ("count", "newman", "binary")
+GENERATE_TYPES: tuple[GenerateType, ...] = ("er", "ws", "ba", "2mode")
 
 
 def _check(value: str, allowed: tuple[str, ...], name: str) -> str:
@@ -37,12 +55,12 @@ def _handle(name: str) -> ThreadleStruct:
 # Process escape hatch
 # --------------------
 def is_available(path: Optional[str] = "threadle") -> bool:
-    """Return whether the Threadle executable can be found."""
+    """Return whether the Threadle CLI executable can be found."""
     return _client_is_available(path)
 
 
 def start_threadle(path: Optional[str] = None):
-    """Start the Threadle CLI process."""
+    """Start the Threadle CLI process in JSON mode."""
     return start(path)
 
 
@@ -56,10 +74,10 @@ def cmd(
     args: Optional[dict[str, Any]] = None,
     *,
     assign: Optional[str] = None,
-    type: Optional[str] = None,
+    type: Optional[StructureType] = None,
     **kwargs: Any,
 ):
-    """Send a raw Threadle command and optionally return an assigned handle."""
+    """Send a raw Threadle command to the backend."""
     if command is None:
         command = kwargs.pop("cmd", None)
     elif "cmd" in kwargs:
@@ -79,10 +97,12 @@ def cmd(
 # Workdir / filesystem
 # --------------------
 def get_workdir():
+    """Return Threadle's current working directory."""
     return call("getwd", locals())
 
 
 def set_workdir(dir: str):
+    """Set Threadle's current working directory."""
     return call("setwd", locals())
 
 
@@ -92,11 +112,12 @@ def sync_wd():
 
 
 def dir(path: Optional[str] = None):
+    """List files in a Threadle-visible directory."""
     return call("dir", locals())
 
 
 def stage_examples_to_wd(folder: str = "threadle_examples", overwrite: bool = True) -> str:
-    """Copy bundled example files into a folder and return its absolute path."""
+    """Copy bundled example files into a local folder."""
     dest = os.path.expanduser(folder)
     if not os.path.isabs(dest):
         dest = os.path.join(os.getcwd(), dest)
@@ -116,18 +137,22 @@ def stage_examples_to_wd(folder: str = "threadle_examples", overwrite: bool = Tr
 # Meta
 # --------------------
 def inventory():
+    """Return the objects currently stored in the Threadle session."""
     return call("i", locals())
 
 
 def i():
+    """Return the objects currently stored in the Threadle session."""
     return inventory()
 
 
 def info(structure: ThreadleName):
+    """Return metadata for a Threadle network or nodeset."""
     return call("info", locals())
 
 
 def preview(structure: ThreadleName):
+    """Return a human-readable preview of a Threadle network or nodeset."""
     return call("preview", locals())
 
 
@@ -143,12 +168,14 @@ def add_aff(
     addmissinghyperedge: bool = True,
     addmissingaffiliation: Optional[bool] = None,
 ):
+    """Add a node-to-hyperedge affiliation in a two-mode layer."""
     if addmissingaffiliation is not None:
         addmissinghyperedge = addmissingaffiliation
     return call("addaff", locals(), drop=("addmissingaffiliation",))
 
 
 def remove_aff(network: ThreadleName, layername: str, nodeid: NodeId, hypername: str):
+    """Remove a node-to-hyperedge affiliation from a two-mode layer."""
     return call("removeaff", locals())
 
 
@@ -160,30 +187,37 @@ def add_edge(
     value: Any = 1,
     addmissingnodes: bool = True,
 ):
+    """Add an edge between two nodes in a one-mode layer."""
     return call("addedge", locals())
 
 
 def remove_edge(network: ThreadleName, layername: str, node1id: NodeId, node2id: NodeId):
+    """Remove an edge between two nodes from a one-mode layer."""
     return call("removeedge", locals())
 
 
 def check_edge(network: ThreadleName, layername: str, node1id: NodeId, node2id: NodeId):
+    """Return whether two nodes are connected in a layer."""
     return call("checkedge", locals())
 
 
 def get_edge(network: ThreadleName, layername: str, node1id: NodeId, node2id: NodeId):
+    """Return the value of an edge between two nodes."""
     return call("getedge", locals())
 
 
 def get_random_edge(network: ThreadleName, layername: str, maxattempts: int = 100):
+    """Return a random edge from a layer."""
     return call("getrandomedge", locals())
 
 
 def get_all_edges(network: ThreadleName, layername: str, offset: int = 0, limit: int = 1000):
+    """Return edges from a one-mode layer with optional pagination."""
     return call("getalledges", locals())
 
 
 def clear_layer(network: ThreadleName, layername: str):
+    """Remove all edges or hyperedges from a layer while keeping the layer."""
     return call("clearlayer", locals())
 
 
@@ -194,41 +228,48 @@ def add_hyper(
     nodes: Optional[Union[list[Any], tuple[Any, ...], str]] = None,
     addmissingnodes: bool = True,
 ):
+    """Add a hyperedge to a two-mode layer."""
     nodes = _collapse(nodes)
     return call("addhyper", locals())
 
 
 def remove_hyper(network: ThreadleName, layername: str, hypername: str):
+    """Remove a hyperedge from a two-mode layer."""
     return call("removehyper", locals())
 
 
 def get_all_hyperedges(network: ThreadleName, layername: str, offset: int = 0, limit: int = 1000):
+    """Return hyperedges from a two-mode layer with optional pagination."""
     return call("getallhyperedges", locals())
 
 
 def get_hyperedge_nodes(network: ThreadleName, layername: str, hypername: str):
+    """Return the nodes affiliated with a hyperedge."""
     return call("gethyperedgenodes", locals())
 
 
 def get_node_hyperedges(network: ThreadleName, layername: str, nodeid: NodeId):
+    """Return the hyperedges affiliated with a node."""
     return call("getnodehyperedges", locals())
 
 
 def add_layer(
     network: ThreadleName,
     layername: str,
-    mode: int,
+    mode: LayerMode,
     directed: bool = False,
-    valuetype: str = "binary",
+    valuetype: LayerValueType = "binary",
     selfties: bool = False,
 ):
+    """Add a one-mode or two-mode relational layer to a network."""
     if str(mode) not in ("1", "2"):
         raise ValueError("mode must be 1 or 2.")
-    _check(valuetype, ("binary", "valued"), "valuetype")
+    _check(valuetype, LAYER_VALUE_TYPES, "valuetype")
     return call("addlayer", locals())
 
 
 def remove_layer(network: ThreadleName, layername: str):
+    """Remove a relational layer and its ties from a network."""
     return call("removelayer", locals())
 
 
@@ -236,7 +277,7 @@ def import_layer(
     network: ThreadleName,
     layername: str,
     file: str,
-    format: str = "edgelist",
+    format: LayerFormat = "edgelist",
     node1col: int = 0,
     node2col: int = 1,
     valuecol: int = 2,
@@ -246,11 +287,13 @@ def import_layer(
     sep: str = "\t",
     addmissingnodes: bool = False,
 ):
-    _check(format, ("edgelist", "matrix"), "format")
+    """Import ties into an existing network layer from a file."""
+    _check(format, LAYER_FORMATS, "format")
     return call("importlayer", locals())
 
 
 def export_layer(network: ThreadleName, layername: str, file: str, header: bool = True, sep: str = "\t"):
+    """Export a network layer as an edge list file."""
     return call("exportlayer", locals())
 
 
@@ -258,6 +301,7 @@ def export_layer(network: ThreadleName, layername: str, file: str, header: bool
 # Nodeset / Node ops
 # ============================================
 def add_node(structure: ThreadleName, nodeid: Optional[NodeId] = None, id: Optional[NodeId] = None):
+    """Add a node to a nodeset or to the nodeset of a network."""
     if nodeid is None:
         nodeid = id
     if nodeid is None:
@@ -266,68 +310,81 @@ def add_node(structure: ThreadleName, nodeid: Optional[NodeId] = None, id: Optio
 
 
 def remove_node(structure: ThreadleName, nodeid: NodeId):
+    """Remove a node from a nodeset or network nodeset."""
     return call("removenode", locals())
 
 
 def get_nbr_nodes(structure: ThreadleName):
+    """Return the number of nodes in a network or nodeset."""
     return call("getnbrnodes", locals())
 
 
 def get_all_nodes(structure: ThreadleName, offset: int = 0, limit: int = 1000):
+    """Return nodes from a network or nodeset with optional pagination."""
     return call("getallnodes", locals())
 
 
 def get_nodeid_by_index(structure: ThreadleName, index: int):
+    """Return the node id at an index position."""
     return call("getnodeidbyindex", locals())
 
 
 def get_random_node(structure: ThreadleName):
+    """Return a random node id from a network or nodeset."""
     return call("getrandomnode", locals())
 
 
 # ============================================
 # Attributes
 # ============================================
-def define_attr(structure: ThreadleName, attrname: str, attrtype: str = "int"):
+def define_attr(structure: ThreadleName, attrname: str, attrtype: AttrType = "int"):
+    """Define a node attribute on a network or nodeset."""
     _check(attrtype, ATTR_TYPES, "attrtype")
     return call("defineattr", locals())
 
 
 def undefine_attr(structure: ThreadleName, attrname: str):
+    """Remove a node attribute definition and its stored values."""
     return call("undefineattr", locals())
 
 
 def get_attr(structure: ThreadleName, nodeid: NodeId, attrname: str):
+    """Return one node attribute value."""
     return call("getattr", locals())
 
 
 def get_attrs(structure: ThreadleName, nodes: Union[str, list[NodeId], tuple[NodeId, ...]], attrname: str):
+    """Return one attribute value for multiple nodes."""
     nodes = _collapse(nodes)
     return call("getattrs", locals())
 
 
 def get_attr_summary(structure: ThreadleName, attrname: str):
+    """Return summary statistics for a node attribute."""
     return call("getattrsummary", locals())
 
 
 def set_attr(structure: ThreadleName, nodeid: NodeId, attrname: str, attrvalue: Any):
+    """Set one node attribute value."""
     return call("setattr", locals())
 
 
 def remove_attr(structure: ThreadleName, nodeid: NodeId, attrname: str):
+    """Remove one node attribute value."""
     return call("removeattr", locals())
 
 
 def generate_attr(
     structure: ThreadleName,
     attrname: str,
-    attrtype: str = "int",
+    attrtype: AttrType = "int",
     min: Optional[Any] = None,
     max: Optional[Any] = None,
     p: float = 0.5,
     chars: str = "m;f;o",
     values: Optional[Union[str, list[Any], tuple[Any, ...]]] = None,
 ):
+    """Generate random values for a node attribute."""
     _check(attrtype, ATTR_TYPES, "attrtype")
     if attrtype == "int":
         min = 0 if min is None else min
@@ -346,10 +403,11 @@ def get_node_alters(
     network: ThreadleName,
     nodeid: NodeId,
     layernames: Optional[Union[str, list[str], tuple[str, ...]]] = "",
-    direction: str = "out",
+    direction: Direction = "out",
     unique: bool = True,
     layername: Optional[Union[str, list[str], tuple[str, ...]]] = None,
 ):
+    """Return alters of a node within one or more layers."""
     _check(direction, DIRECTIONS, "direction")
     if layername is not None and not layernames:
         layernames = layername
@@ -361,11 +419,12 @@ def get_random_alter(
     network: ThreadleName,
     nodeid: NodeId,
     layernames: Optional[Union[str, list[str], tuple[str, ...]]] = "",
-    direction: str = "both",
+    direction: Direction = "both",
     balanced: bool = False,
     weighted: bool = False,
     layername: Optional[Union[str, list[str], tuple[str, ...]]] = None,
 ):
+    """Return a random alter of a node."""
     _check(direction, DIRECTIONS, "direction")
     if layername is not None and not layernames:
         layernames = layername
@@ -377,10 +436,11 @@ def get_degree(
     network: ThreadleName,
     nodeid: NodeId,
     layernames: Optional[Union[str, list[str], tuple[str, ...]]] = None,
-    direction: str = "out",
+    direction: Direction = "out",
     unique: bool = True,
     layername: Optional[Union[str, list[str], tuple[str, ...]]] = None,
 ):
+    """Return the degree of a node within one or more layers."""
     _check(direction, DIRECTIONS, "direction")
     if layername is not None and not layernames:
         layernames = layername
@@ -395,6 +455,7 @@ def shortest_path(
     layernames: Optional[Union[str, list[str], tuple[str, ...]]] = None,
     layername: Optional[Union[str, list[str], tuple[str, ...]]] = None,
 ):
+    """Return the shortest path distance between two nodes."""
     if layername is not None and not layernames:
         layernames = layername
     layernames = _collapse(layernames)
@@ -408,6 +469,7 @@ def shortest_paths(
     layernames: Optional[Union[str, list[str], tuple[str, ...]]] = None,
     layername: Optional[Union[str, list[str], tuple[str, ...]]] = None,
 ):
+    """Compute category-level average shortest paths and return a result network handle."""
     if layername is not None and not layernames:
         layernames = layername
     layernames = _collapse(layernames)
@@ -418,25 +480,28 @@ def shortest_paths(
 # ============================================
 # Network measures / transforms
 # ============================================
-def degree(network: ThreadleName, layername: str, attrname: Optional[str] = None, direction: str = "out"):
+def degree(network: ThreadleName, layername: str, attrname: Optional[str] = None, direction: Direction = "out"):
+    """Compute node degree values for a layer."""
     _check(direction, DIRECTIONS, "direction")
     return call("degree", locals())
 
 
 def density(network: ThreadleName, layername: str, samplesize: int = 200):
+    """Compute or estimate the density of a layer."""
     return call("density", locals())
 
 
 def dichotomize(
     network: ThreadleName,
     layername: str,
-    cond: str = "ge",
+    cond: NumericCondition = "ge",
     threshold: Any = 1,
     truevalue: Any = 1,
     falsevalue: Any = 0,
     newlayername: Optional[str] = None,
 ):
-    _check(cond, CONDITIONS[:6], "cond")
+    """Create a binary layer by thresholding a valued one-mode layer."""
+    _check(cond, NUMERIC_CONDITIONS, "cond")
     return call("dichotomize", locals())
 
 
@@ -446,6 +511,7 @@ def components(
     attrname: Optional[str] = None,
     layname: Optional[str] = None,
 ):
+    """Compute connected components for a network layer."""
     if layername is None:
         layername = layname
     if layername is None:
@@ -456,28 +522,32 @@ def components(
 def symmetrize(
     network: ThreadleName,
     layername: str,
-    method: str = "max",
+    method: SymmetrizeMethod = "max",
     newlayername: Optional[str] = None,
 ):
-    _check(method, ("max", "min", "minnonzero", "average", "sum", "product"), "method")
+    """Create a symmetric version of a one-mode layer."""
+    _check(method, SYMMETRIZE_METHODS, "method")
     return call("symmetrize", locals())
 
 
 def project_two_mode(
     network: ThreadleName,
     layername: str,
-    method: str = "count",
+    method: ProjectMethod = "count",
     newlayername: Optional[str] = None,
 ):
-    _check(method, ("count", "newman", "binary"), "method")
+    """Project a two-mode layer to a one-mode layer."""
+    _check(method, PROJECT_METHODS, "method")
     return call("projecttwomode", locals())
 
 
 def pack(network: ThreadleName, layername: Optional[str] = None):
+    """Convert one or all dynamic layers to a static memory-efficient representation."""
     return call("pack", locals())
 
 
 def unpack(network: ThreadleName, layername: Optional[str] = None):
+    """Convert one or all static layers back to an editable representation."""
     return call("unpack", locals())
 
 
@@ -485,17 +555,20 @@ def unpack(network: ThreadleName, layername: Optional[str] = None):
 # Creation / IO / lifecycle
 # ============================================
 def create_nodeset(var: str, name: Optional[str] = None, createnodes: int = 0):
+    """Create a nodeset and return its Threadle handle."""
     call("createnodeset", locals(), assign=var)
     return _handle(var)
 
 
 def create_network(var: str, nodeset: ThreadleName, name: Optional[str] = None):
+    """Create a network from a nodeset and return its Threadle handle."""
     call("createnetwork", locals(), assign=var)
     return _handle(var)
 
 
-def load_file(name: str, file: str, type: str, pack: bool = False):
-    _check(type, ("network", "nodeset"), "type")
+def load_file(name: str, file: str, type: StructureType, pack: bool = False):
+    """Load a nodeset or network file and return its Threadle handle."""
+    _check(type, STRUCTURE_TYPES, "type")
     file2 = os.path.expanduser(file)
     old_wd = None
     if os.path.dirname(file2):
@@ -513,10 +586,12 @@ def load_file(name: str, file: str, type: str, pack: bool = False):
 
 
 def save_file(structure: ThreadleName, file: str = ""):
+    """Save a Threadle network or nodeset to disk."""
     return call("savefile", locals())
 
 
 def load_script(file: str):
+    """Load and run a Threadle script file."""
     return call("loadscript", locals())
 
 
@@ -526,7 +601,7 @@ def load_examples(
     set_workdir_to_examples: bool = True,
     set_workdir: Optional[bool] = None,
 ):
-    """Load bundled examples and return a dict of Threadle handles."""
+    """Load bundled example datasets and return their Threadle handles."""
     if set_workdir is not None:
         set_workdir_to_examples = set_workdir
 
@@ -560,31 +635,37 @@ def load_examples(
 
 
 def export(network: ThreadleName, file: str, layername: str, format: str = "gexf"):
+    """Export a network layer to an external graph format."""
     return call("export", locals())
 
 
 def delete(structure: ThreadleName):
+    """Delete a Threadle structure from the current session."""
     return call("delete", locals())
 
 
 def delete_all():
+    """Delete all Threadle structures from the current session."""
     return call("deleteall", locals())
 
 
 # ============================================
 # Subsetting / filtering
 # ============================================
-def filter(name: str, nodeset: ThreadleName, attrname: str, cond: str, attrvalue: Any = None):
+def filter(name: str, nodeset: ThreadleName, attrname: str, cond: Condition, attrvalue: Any = None):
+    """Create a filtered nodeset from node attribute values."""
     _check(cond, CONDITIONS, "cond")
     call("filter", locals(), assign=name)
     return _handle(name)
 
 
-def filter_nodeset(name: str, nodeset: ThreadleName, attrname: str, cond: str, attrvalue: Any = None):
+def filter_nodeset(name: str, nodeset: ThreadleName, attrname: str, cond: Condition, attrvalue: Any = None):
+    """Alias for filter."""
     return filter(name, nodeset, attrname, cond, attrvalue)
 
 
 def subnet(name: str, network: ThreadleName, nodeset: ThreadleName):
+    """Create a subnetwork induced by a nodeset."""
     call("subnet", locals(), assign=name)
     return _handle(name)
 
@@ -595,7 +676,7 @@ def subnet(name: str, network: ThreadleName, nodeset: ThreadleName):
 def generate(
     network: ThreadleName,
     layername: str,
-    type: str,
+    type: GenerateType,
     p: Optional[float] = None,
     k: Optional[int] = None,
     beta: Optional[float] = None,
@@ -603,7 +684,8 @@ def generate(
     h: Optional[int] = None,
     a: Optional[float] = None,
 ):
-    _check(type, ("er", "ws", "ba", "2mode"), "type")
+    """Generate random ties in a network layer."""
+    _check(type, GENERATE_TYPES, "type")
     return call("generate", locals())
 
 
@@ -620,6 +702,7 @@ def rwdistances(
     savesteps: bool = False,
     layername: Optional[Union[str, list[str], tuple[str, ...]]] = None,
 ):
+    """Estimate category distances with random walks and return a result network handle."""
     if layername is not None and not layernames:
         layernames = layername
     layernames = _collapse(layernames)
@@ -639,6 +722,7 @@ def rwfpt(
     weighted: bool = False,
     layername: Optional[Union[str, list[str], tuple[str, ...]]] = None,
 ):
+    """Estimate category mean first-passage times with random walks and return a result network handle."""
     if layername is not None and not layernames:
         layernames = layername
     layernames = _collapse(layernames)
@@ -647,10 +731,12 @@ def rwfpt(
 
 
 def random_seed(seed: int = 6031769):
+    """Set Threadle's random seed."""
     return call("randomseed", locals())
 
 
 def setting(name: str, value: Any):
+    """Set a Threadle backend setting or a threadlepy runtime setting."""
     if name.lower() == "verbose":
         from . import client
 

threadlepy-0.1.2/src/threadlepy/py.typed

@@ -0,0 +1 @@
+

{threadlepy-0.1.1 → threadlepy-0.1.2/src/threadlepy.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: threadlepy
-Version: 0.1.1
+Version: 0.1.2
 Summary: Python client for the Threadle CLI JSON interface.
 Author: Yukun Jiao
 License-Expression: MIT

{threadlepy-0.1.1 → threadlepy-0.1.2}/src/threadlepy.egg-info/SOURCES.txt

@@ -9,6 +9,7 @@ scripts/test_session.py
 src/threadlepy/__init__.py
 src/threadlepy/client.py
 src/threadlepy/commands.py
+src/threadlepy/py.typed
 src/threadlepy.egg-info/PKG-INFO
 src/threadlepy.egg-info/SOURCES.txt
 src/threadlepy.egg-info/dependency_links.txt