semvec/pypi-packages huggingface dataset:
usfiscaldata 0.1.0
Client for US Treasury Fiscal Data API
Requires Python: >=3.8

# Treaury Fiscal Data API Client for Python

Python client for accessing the [U.S. Treasury Fiscal Data API](https://fiscaldata.treasury.gov/api-documentation/).

## Installation

```bash
python -m pip install usfiscaldata
```

## Usage

### Example

```python
from usfiscaldata import FiscalData, Filter

client = FiscalData()
endpoint = client.v1.accounting.od.auctions_query
filter_ = Filter()
filter_["record_date"] <= "1984-01-01"
response = endpoint.all(filter=filter_)
df = response.df
print(df.shape)
print(df.head())
```

### Endpoints

The client implements a generic dot-accessor interface for the endpoints, so you need to know the full endpoint path.
The endpoint can also be specified as a string.

```python
from usfiscaldata import FiscalData

client = FiscalData()
endpoint = client.v2.debt.tror.data_act_compliance
endpoint = client("v2/debt/tror/data_act_compliance")
```

### Filters

Filters are specified using a dictionary-like `Filter` object.

```pythonpython
from fiscaldata import Filter
filter_ = Filter()
filter_["record_date"] <= "2000-01-01"
filter_["amount"] > 1000
filter_["fiscal_year"].isin([1999, 2000, 2001])
```

### Response Pagination

The response object contains a `meta` attribute with pagination information, and a `next_page` method to retrieve the next page of results.
When there are no more pages, `next_page` returns `None`.
You can also just call `.all()` as in above example.
lifx-photons-interactor 0.16.11
A server for interacting with LIFX lights over the LAN
Requires Python: >=3.12
Keywords: lifx, photons

Photons Interactor
==================

A `Photons <https://photons.delfick.com>`_ powered server for
interacting with LIFX lights over the lan.

The server allows us to do continuous discovery and information gathering so that
all commands are super fast.

You can find documentation at
https://photons.delfick.com/apps/interactor/index.html
grapes 0.10.4
Helper for dataflow based programming

# grapes

A simple library for dataflow programming in python.
It allows you to organize your computation as a directed acyclic graph.

## Quickstart

For a more detailed explanation, refer to the [documentation](https://giuliofolettograpes.readthedocs.io/).
Here's what you need to know to get started quickly.

Install `grapes` from PyPI with

```console
pip install grapes
```

Define a graph by adding steps and binding functions to them:

```python
import grapes as gr
g = gr.Graph()
gr.add_step(g, "b", "compute_b", "a")
gr.add_step(g, "c", "compute_c", "b")
gr.update_internal_context(g,
    {
        "compute_b": lambda a: 2*a,
        "compute_c": lambda b: b+1
    }
)
gr.finalize_definition(g)
```

Execute the graph to find your target, starting from your input context.

```python
context = {"a": 3}
target = "c"
result = gr.execute_graph_from_context(g, context, target)
print(result["c"])  # 7
```

## Additional remarks

The bulk of `grapes` development was done by Giulio Foletto in his spare time.
See `LICENSE.txt` and `NOTICE.txt` for details on how `grapes` is distributed.

`grapes` is inspired by [`pythonflow`](https://github.com/spotify/pythonflow) but with substantial modifications.

It relies internally on [`networkx`](https://networkx.org/) for graph management and on [`pygraphviz`](https://github.com/pygraphviz/pygraphviz) for graph visualization.

Most of the development of `grapes` was done before AI coding tools were available.
However, recent edits (September 2025) were assisted by GitHub Copilot, especially for writing docstrings.
icspacket 0.2.4
Python classes to interact with industrial control systems (ICS) using various protocols.
Requires Python: >=3.10
Keywords: ics, ics-security, libiec61850, iec61850, iso8823, iso8237, cotp, tpkt, goose

# icspacket

A collection of Python classes and tools to interact with industrial control
systems using their protocols. Currently supported protocols are:

```
- DNP3.0 (IEEE 1815)
- MMS (ISO 9506) and mappings for IEC 61850
- ACSE (X.227)
- COPP (X.226)
- COSP (X.225)
- COTP (X.224)
- TPKT (RFC1006)
```

**Please review the documentation for more information and tools: [icspacket-docs](https://matrixeditor.github.io/icspacket/)**

**CI Status**

|Target|Status|
|:----:|------|
|Docs|[![CI: Build and Deploy Docs](https://github.com/MatrixEditor/icspacket/actions/workflows/ci-docs.yml/badge.svg)](https://github.com/MatrixEditor/icspacket/actions/workflows/ci-docs.yml)|
|Linux 3.10-3.13|[![CI: Run Tests on Linux](https://github.com/MatrixEditor/icspacket/actions/workflows/ci-pytest-linux.yml/badge.svg)](https://github.com/MatrixEditor/icspacket/actions/workflows/ci-pytest-linux.yml)|
|Mac 3.10-3.13|[![CI: Run Tests on MacOS](https://github.com/MatrixEditor/icspacket/actions/workflows/ci-pytest-macos.yml/badge.svg)](https://github.com/MatrixEditor/icspacket/actions/workflows/ci-pytest-macos.yml)|
|Windows 3.10-3.13|[![CI: Run Tests on Windows](https://github.com/MatrixEditor/icspacket/actions/workflows/ci-pytest-windows.yml/badge.svg)](https://github.com/MatrixEditor/icspacket/actions/workflows/ci-pytest-windows.yml)|

## Installation

There are pre-built wheels on PyPI for Python 3.10 to 3.13 for Linux, Windows
and MacOS. Any other Python version is not officially supported.

```bash
pip install icspacket
```

Alternatively, to build from source, Python development headers, CMake, Ninja
and a compatible compiler must be installed (preferably GCC, MSVC and clang work
too).

```bash
pip install git+https://github.com/MatrixEditor/icspacket
```

## Disclaimer

This project is shared openly to help the community explore, learn, and advance
research on industrial control systems, networking protocols, and related
technologies. Our goal is to provide a resource that encourages experimentation,
collaboration, and education.

The material in this repository is **for research and learning only**. It is not
intended for direct use in production systems or commercial deployments,
especially within live industrial environments where safety and reliability are
critical.

If you decide to build on this work, we encourage you to adopt secure coding
practices, apply a structured security development process, and consider how
you’ll generate and track indicators of compromise in line with your specific
goals.

## License

Distributed under the GNU General Public License (V3). See [License](LICENSE) for more information.
website-crawler-sdk 0.1.5
The official Python SDK for the Website Crawler API
Requires Python: >=3.6

# website_crawler_sdk

A Python SDK for interacting with [WebsiteCrawler.org](https://www.websitecrawler.org), designed to simplify crawling tasks via API. Submit URLs, monitor crawling status, and retrieve structured data in JSON format for ingesting in LLMs with ease. 

To use the API, get your free API key from [WebsiteCrawler.org](https://www.websitecrawler.org) settings page (login > visit settings page).

##  Features

- Trigger crawl jobs remotely
- Monitor crawling status in real time
- Access current URLs being crawled
- Fetch crawl output as raw JSON
- Respect API wait times dynamically

##  Installation

You can install it locally for development:

```bash
pip install website_crawler_sdk
```

## Demo script

The objective of the following script is to submit a URL to webistecrawler via its API, get URLs being processed by the crawler in realtime and retrieve the JSON data of the crawled website via the API

```
import time
from website_crawler_sdk import WebsiteCrawlerConfig, WebsiteCrawlerClient

"""
Author: Pramod Choudhary (websitecrawler.org)
Version: 1.1
Date: July 10, 2025
"""

# Replace with your actual API key, target URL, and limit
YOUR_API_KEY = "YOUR_API_KEY" #Your API key goes here
URL = "YOUR_URL" #Enter a non redirecting URL/domain with https or http
LIMIT = YOUR_LIMIT #Change YOUR_LIMIT 

def main():
    cfg = WebsiteCrawlerConfig(YOUR_API_KEY)
    client = WebsiteCrawlerClient(cfg)

    # Submit URL to WebsiteCrawler.org for crawling
    client.submit_url_to_website_crawler(URL, LIMIT) #Submit the URL and Limit to websitecrawler via API

    while True:
        task_status = client.get_task_status() #Start retrieving data if the task_status is true
        print(f"{task_status} << task status")
        time.sleep(2)  #Wait for 2 seconds

        if not task_status:
           break

        if task_status:
            status = client.get_crawl_status() #get_crawl_status() method gets the crawl status
            currenturl = client.get_current_url() #get_current_url() method gets the current URL
            data = client.get_crawl_data() # get_crawl_data() method gets the structured data once crawling has completed

            if status:
                print(f"Current URL:: {status}")


            if status == "Crawling": #Crawling is one of the status
                print(f"Current URL:: {currenturl}")

            if status == "Completed!":  #Completed! (with exclamation) is one of the status
                print("Task has been completed... closing the loop and gettint the data...")
                if data:
                    print(f"JSON Data:: {data}")
                    time.sleep(20)  # Give extra time for large JSON response
                    break
            
           

    print("Job over")

if __name__ == "__main__":
    main()

```