semvec/pypi-packages huggingface dataset:
argil 0.0.6
SDK for the Argil API
Requires Python: >=3.7

# Argil Python SDK

Welcome to the Argil Python SDK. This library provides a simple and intuitive interface to interact with Argil's API, allowing you to leverage the power of AI-driven workflows and automations in your Python applications.

For the full Argil documentation, please visit https://docs.argil.ai.

## Table of Contents

- [Installation](#installation)
- [Usage](#usage)
- [API Reference](#api-reference)
- [Contributing](#contributing)
- [License](#license)

## Installation

This library is distributed on PyPI. In order to add it as a dependency, run the following command:

```bash
pip install argil
```

## Usage

Here is a quick example of how to use the Argil Python SDK:

```python
from argil import ArgilSdk

sdk = ArgilSdk(api_key='your-api-key') // You can also provide your API key from ARGIL_API_KEY env variable

# Run a workflow
run = sdk.workflows.run('workflow-id', {
    "input_field_name1": $input_value1,
    "input_field_name2": $input_value2
    // Input fields depends on the workflow you run, please look at our full documentation.
})

# Get a workflow run
workflow_run = sdk.workflowRuns.get(run['id'])

# List all workflow runs
workflow_run = sdk.workflowRuns.list()

print(workflow_run)
```

## API Reference

The Argil Python SDK provides the following classes:

- ArgilSdk: The main class that provides access to the different services.
- Workflows: A class for interacting with the Workflows service of the Argil API.
- WorkflowRuns: A class for interacting with the WorkflowRuns service of the Argil API.
- ArgilConfig: A class for managing the configuration for the SDK.
- ArgilError: A custom error class for providing more detailed and specific error messages.

For more detailed information, please refer to the source code and inline comments.

## Contributing

We welcome contributions from the community.

## License

This project is licensed under the GPL-3.0-or-later license. For more information, see the  [LICENSE.md](LICENSE.md) file.

## Support

If you encounter any problems or have any questions, please open an issue on our [GitHub repository](https://github.com/argildotai/argil-sdk-python/issues).

## Acknowledgements

This project uses the following open-source packages:

- [requests](https://github.com/psf/requests): A simple, yet elegant HTTP library.

## Contact

For any inquiries, please contact us at briva@argil.ai.
FeishuBitableAPI 3.3.3
A Python API for Feishu Bitable

# Feishu-Bitable-Python-API
面向飞书的多维表格开发的Python API

PyPI发布页 [https://pypi.org/project/FeishuBitableAPI/](https://pypi.org/project/FeishuBitableAPI/)

更多模块文档请阅读 [https://github.com/BlueSkyXN/Feishu-Bitable-Python-API/tree/main/docs](https://github.com/BlueSkyXN/Feishu-Bitable-Python-API/tree/main/docs)

# License
本项目同时支持 [GPLv3](https://github.com/BlueSkyXN/Feishu-Bitable-Python-API/blob/main/LICENSE) 标准许可 以及 商业许可，若要获取豁免各项开源限制的情况请联系作者购买商业许可。

如果你计划成为本仓库贡献者，你知晓且同意你的贡献代码将无偿、释放版权地形式提供给本项目，即你不能通过该项目的整体进行获利 或者 以贩卖交易等方式通过非你编写的代码部分进行获利
chialisp_loader 0.1.0
Provides `load_puzzle` which dynamic rebuilds if `chialisp_builder` is available.

# chialisp_loader

This tiny wheel exports `load_program`, which is used to load (chialisp)[https://chialisp.com/] programs from resources included with python wheels.

Chialisp `.clsp` files are compiled into `.hex` output. Only `.hex` output files need to be included in binary wheels

When `load_program` is called, it tries to import `chialisp_builder`. If it fails, it assumes this is running at deploy time: any `.clsp` files are ignored, and the corresponding program is loaded from the `.hex` file.
chialisp_builder 0.1.0
Allow on-demand builds of chialisp with recursive dependency checking.

# Chialisp Builder

Use this wheel in conjunction with `runtime_builder` to manage building of chialisp at build time or during development.

# Use

Add `chialisp_builder` as a buildtime dependency and a development-time dependency. Don't add it as a runtime dependency, as the clvm `.hex` files should be built and included with the wheel. The source does not need to be.

Add `chialisp_loader` as a runtime dependency to get the `load_program` function, which will call the building function if present (as it should be at development time.)

# FAQ

Why isn't this included as part of `runtime_builder`?

The `runtime_builder` wheel is intended to provide a general solution for non-python artifacts. Although Chialisp build was the inspiration for `runtime_builder`, it's just one potential use. This wheel is the specific implementation of chialisp builds for use with `runtime_builder`.
CHASM-NuSpacesim 1.0.0
CHerenkov Air Shower Model
Requires Python: >=3.10

![CHASM_logo](https://user-images.githubusercontent.com/64815713/217383767-9bdf9ff9-88ec-43f5-b670-c92de67aa085.png)

# CHASM (CHerenkov Air Shower Model)

CHASM is a python package which leverages the universality of charged particles in an extensive air shower to produce a deterministic prediction of the Cherenkov light signal for a given shower profile and geometry. At samples throughout the domain of all shower development stages and altitudes, the angular and yield distributions of Cherenkov light have been calculated at an array of distances from a shower axis. Chasm accesses and interpolates between these distributions at runtime to produce the aggregate signal from the whole shower at user defined telescope locations.

# Installation

To install from pip:

```
pip install CHASM-NuSpacesim
```

To install from source:

1. `git clone https://github.com/ikepc1/CHASM_NuSpacesim`
2. `cd CHASM_NuSpacesim`
3. `python3 -m pip install -e .`

# Usage

CHASM has implementations of both upward and downward going shower axes in either flat planar or curved atmospheres. A shower profile can be defined either by Gaisser-Hillas parameters, or as an array of particle counts and at a corresponding array of depths. Cherenkov yield distributions can be sampled along the shower axis, or in a mesh of points surrounding the axis, at which charged particles are distributed according to the NKG lateral distribution. The first step is to create a simulation.

```
import CHASM as ch

sim = ch.ShowerSimulation()
```

Then add an axis. The origin of the coordinate system is where the axis meets the ground. It is defined by a polar angle, azimuthal angle, and keyword arguments for the ground level and whether to account for atmospheric curvature.
```
sim.add(ch.DownwardAxis(theta, phi, ground_level = 0., curved = False))
```
or
```
sim.add(ch.UpwardAxis(theta, phi, ground_level = 0., curved = False))
```

Then add a shower.

```
sim.add(ch.GHShower(X_max, N_max, X0, Lambda))
```
or
```
sim.add(ch.UserShower(X, N))
```

Now we add photon counters. Both spherical CORSIKA IACT style counters and flat counting apertures are available.

```
sim.add(ch.SphericalCounters(counter_vectors, counter_radius))
```
or
```
sim.add(ch.FlatCounters(counter_vectors, counter_radius))
```

Finally, we define the Cherenkov wavelength interval of interest.

```
sim.add(ch.Yield(min_l, max_l, N_bins = 1))
```

We can now run the simulation, and generate signals. The simulation's run method takes two keyword boolean flags, 'mesh' specifies whether to use mesh sampling around the shower axis, 'att' specifies whether to use atmospheric extinction along the travel paths of the light. The run method returns a ShowerSignal object, which contains the number of photons, their arrival times, their wavelengths, and vectors to their source points.

```
sig = sim.run(mesh = True)
```

CHASM can also write its output to the eventio format used by CORSIKA IACT. The function that does this takes ShowerSignal object and the target filename as arguments.

```
ch.write_ei_file(sig, 'filename.dat')
```
hotdag 0.7.2
Hot evaluation of dbt DAG selectors
Requires Python: >=3.7

# HotDAG

[![PyPI - Version](https://img.shields.io/pypi/v/hotdag.svg)](https://pypi.org/project/hotdag)
![GitHub Workflow Status (with branch)](https://img.shields.io/github/actions/workflow/status/nicholasyager/hotdag/test.yml?branch=main)

-----

HotDAG is a lightweight tool that allows for testing for dbt node selectors against dbt project manifests
on a local filesystem, stored on dbt Cloud, or located remotely. Once evaluated, this selection of nodes
can be returned as a list of `unique_id`s, a JSON list of `unique_id`s, or as an SVG of the selection.

**Table of Contents**
- [But Why Though?](#butwhythough)
- [Installation](#installation)
- [License](#license)

## But Why Though?
Sometimes, it can be valuable while developing locally to have a means of quickly testing a selection string against
the production version of a dbt project without fiddling with the generated docs site or compiling the current
production branch. Instead, HotDAG lets you quickly test and visualize your selection using your project's manifest,
whether its on your local file system, stored remotely and accessible via URL, or hosted on dbt Cloud.

## Installation

```console
pip install hotdag
```

## Getting Started
There are a few primary ways to use HotDAG. The most common way is to load a local manifest file and list the
selection. This is roughly equivalent to using `dbt ls`

```console
hotdag --input file --file targets/manifest.json --select "resource_type:source+"

source.example.example.users
model.example.stg_users
model.example.users
test.example.not_null_stg_users_id
test.example.unique_stg_users_id
```

HotDAG really shines, however, if you want to see a diagram of the selection.

```console
hotdag --input file --output svg \
    --file targets/manifest.json \
    --select "resource_type:source+"
```
![graph.png](graph.png)

Also of use is the ability to directly reference the latest manifest from your project's dbt Cloud
job. For example:

```console
hotdag --input dbt_cloud --output svg \
    --account-id 1234 --job-id 9876 \
    --select "resource_type:source+"
```

## Roadmap
- [ ] Styling the SVG output to better distinguish between node types.
- [ ] Improved error handling for remote resource failures.
- [ ] Add rational defaults (e.g. default input to `file` and `--file` to the targets directory)
- [ ] Verify support for Selectors (as defined in yaml)

## License

`hotdag` is distributed under the terms of the [MIT](https://spdx.org/licenses/MIT.html) license.