semvec/pypi-packages huggingface dataset:
khang-stesting 0.0.13
Streaming video data via networks
Keywords: python,video,stream,video stream,camera stream,sockets


# vidstream

Under construction! Not ready for use yet! Currently experimenting and planning!

Developed by Florian Dedov from NeuralNine (c) 2020

## Examples of How To Use (Buggy Alpha Version)

Creating A Server

```python
from vidstream import StreamingServer

server = StreamingServer('127.0.0.1', 9999)
server.start_server()

# Other Code

# When You Are Done
server.stop_server()
```

Creating A Client
```python
from vidstream import CameraClient
from vidstream import VideoClient
from vidstream import ScreenShareClient

# Choose One
client1 = CameraClient('127.0.0.1', 9999)
client2 = VideoClient('127.0.0.1', 9999, 'video.mp4')
client3 = ScreenShareClient('127.0.0.1', 9999)

client1.start_stream()
client2.start_stream()
client3.start_stream()
```

Check out: https://www.youtube.com/c/NeuralNine
quollio-data-profiler 0.2.1
Quollio Data Profiler
Requires Python: >=3.8

# quollio-data-profiler

# Description
This system collects advanced metadata like table to table lineage or anomaly record and ingests them to QDC.


# Prerequisite
Before you begin to use this, you need to do the following.
- Add your assets to QDC with metadata agent.
- Issue External API client id and client secret on QDC.

# Install
Install with the following command.  
`pip install quollio-data-profiler`

# Usage
Here is an example of creating a view for snowflake lineage. Please enter any values for <>.  
```
from quollio_data_profiler.repository.qdc import QDCExternalAPIClient
from quollio_data_profiler.repository.snowflake import SnowflakeConnectionConfig
from quollio_data_profiler.snowflake_lineage_profiler import execute


def view_build_only():
    company_id = "<company id issued by quollio.>"
    build_view_connection = SnowflakeConnectionConfig(
            account_id="<Snowflake account id. Please use the same id of metadata agent.>",
            account_role="<Role necessary for creating view in your account>",
            account_user="<user name>",
            account_password="<password>",
            account_warehouse="<compute warehouse>", 
    )
    qdc_client = QDCExternalAPIClient(
        client_id="<client id issued on QDC.>",
        client_secret="<client secret>",
        base_url="<base endpoint>",
    )
    execute(
        company_id=company_id,
        sf_build_view_connections=build_view_connection,
        qdc_client=qdc_client,
        is_view_build_only=True,
    )

if __name__ == "__main__":
    view_build_only()
``` 
Please refer to the scripts in `./examples` for other usages.


# Development
## How to test
### Unittest
1. Run `make test`
NUIT 0.3
Wrapper for source term alaysis code NUIT

# Contents
- [Summary](#summary)
- [Install](#install)
- [Get Started](#get-started)
- [Reference](#reference)

# Summary
pyNUIT is a package in Python which wrappers the source term analysis code NUIT, and integrates various util tools for its control and management.

# Install
1. Using git clone: `git clone https://github.com/thu-inet/pyNUIT.git`
2. Download the zip and unzip to destination path

Only a few basic Python packages are required, including:
- Numpy
- Matplotlib
- Pandas

# Get Started
The most basic module is nt.Model and nt.Output, for management of NUIT input model and its output.
```
# import pyNUIT
import pyNUIT as nt

# define the model
model = nt.Model()
model.add_nuclide("U235", 0.85)
model.add_nuclide("U238", 4.15)

# define power history
for i in range(10):
    model.add_burnup(time=10, unit='day', val=800E-6)

# define the output
model.set_output("isotope", print_all_step=0)

# library configuration
model.set_library(r"D:\\NUIT\\NUITLib_HTGR_900k")

# run the model to get output
out = model("model.xml", nuitpath="D:\\NUIT\\NUITx.exe")

# read calculation results
burnup = out.burnups[-1]
density = out.get_nuclide_mass("Cs137")[-1]
print(f"Nuclide density of Cs137 at {burnup} MWd/kgU is {density} n/cm/barn")
```
Histogram class is used to represent the power history, and can transfer its power history into nt.Model to form a complete model.

```

# define two histogram instances
histo1 = nt.Histogram(["2019-01-15 00:00", "2019-02-26 00:00", "2019-03-26 00:00"], [(0,0), (3.7E6,3.7E6), (3.7E6, 0)])
histo2 = nt.Histogram(["2019-05-28 00:00", "2019-07-02 00:00"], [(0, 0), (3E6, 3E6)])

# concatenate two histograms
histo = histo1 + histo2

# pass the power history to model
histo.model = model
model = histo.to_model(step_length=10*86400)
```

Classes in nt.data are used to interact with data libraries.
```
# read the multi-group xs lib
mgxslib = nt.data.MGXSlib.from_datfile("D:\\NUIT\\NUITLib_HTGR_900k\\NuitMgXsLib.dat")

# use existing flux data to collapse into one-group xslib
xslib = mgxslib.to_xslib(flux)

# check the xs of Cs134, MT=102 reaction
print(f"Cross section of Cs-134 Reaction(102) is {xslib("Cs134")(102)}")

# export xslib into .dat file
xslib.to_datfile("xslib.dat")
```
# Reference