semvec/pypi-packages huggingface dataset:
asdf-wcs-schemas 0.5.0
ASDF WCS schemas
Requires Python: >=3.9

# asdf-wcs-schemas
![CI](https://github.com/asdf-format/asdf-wcs-schemas/workflows/CI/badge.svg)
[![pre-commit](https://img.shields.io/badge/pre--commit-enabled-brightgreen?logo=pre-commit&logoColor=white)](https://github.com/pre-commit/pre-commit)
[![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
[![Imports: isort](https://img.shields.io/badge/%20imports-isort-%231674b1?style=flat&labelColor=ef8336)](https://pycqa.github.io/isort/)

This package provides ASDF schemas for validating WCS tags. Users should not need to install this directly; instead, install an implementation package such as gwcs, which includes asdf-wcs-schemas as a dependency.
timeplus-neutrino 0.1.15
Timeplus neutrino is a python library for Timeplus AI agent

# neutrino
Neutrinos are nearly massless and can pass through matter effortlessly, representing smooth and efficient data onboarding.


# pipeline build

install neutrino 'pip install timeplus-neutrino'

1. run timeplus enterprise
2. export following environment
  
```sh
export TIMEPLUS_HOST=localhost
export TIMEPLUS_AISERVICE_USER=user
export TIMEPLUS_AISERVICE_PASSWORD=password
export TIMEPLUS_AISERVICE_DB=aiservice
```

3. run following python code

```python
import os
import json
from neutrino.conf import TimeplusAgentConfig
from neutrino.pipeline.cdc import build_debezium_pipeline_sync

from neutrino.utils.tools import extract_code_blocks_with_type

agent_config = TimeplusAgentConfig()
# config open ai compatible model
#agent_config.config("default", "https://generativelanguage.googleapis.com/v1beta/openai/", os.environ["GEMINI_API_KEY"], "gemini-2.5-pro-preview-06-05")
agent_config.config("default", "https://api.openai.com/v1", os.environ["OPENAI_API_KEY"], "gpt-4o")

# config kafka
kafka_topic = "mongodb.lumi_data.unstructured_data"
kafka_config = {
    "security.protocol": 'PLAINTEXT',
    "bootstrap.servers":'localhost:19092'
}

# config kafka with SASL
'''

kafka_topic = "demo.cdc.mysql.retailer.orders"
kafka_config = {
    "security.protocol": 'SASL_SSL',
    "bootstrap.servers":'kafka.demo.timeplus.com:9092',
    "sasl.mechanism": 'PLAIN',
    "sasl.username":  'demo',
    "sasl.password":  'demo123',
    "enable.ssl.certificate.verification": 'false'
}
'''

# external stream settings
settings = {
	"type" :'s3',
    "access_key_id" : 'minioadmin',
    "secret_access_key" : 'minioadmin',
    "region" : 'us-east-1',
    "bucket" : 'timeplus',
    "data_format" : 'JSONEachRow',
    "endpoint" : 'http://minio:9000',
    "write_to" : 'lumi/data.json',
    "use_environment_credentials" : False
}

result = build_debezium_pipeline_sync(kafka_topic, kafka_config, database="test", target_stream_settings=settings)

print(f"the pipeline building for topic {kafka_topic} result is: {result}")

extracted_codes =extract_code_blocks_with_type(result)
extracted_code_type, extracted_code_content = extracted_codes[0]
print(f"the extracted code type is: {extracted_code_type}")

extracted_code_content_obj = json.loads(extracted_code_content)
print(f"the extracted code content is: {json.dumps(extracted_code_content_obj, indent=2)}")  

print(f"the extracted source_stream is: {extracted_code_content_obj["source_stream"]}")
print(f"the extracted target_stream is: {extracted_code_content_obj["target_stream"]}")
print(f"the extracted extraction_mv is: {extracted_code_content_obj["extraction_mv"]}")
```
django-carpet 0.4.5
Foundational functionalities for Django
Requires Python: >=3.11

# Django Carpet 0.4.5

This package contains the base function and classes for a Django project

The project has the following sections:
- env
- exceptions
- mixins
- paginate
- response
- validators
- xml_element

```text
Note: This package requires python 3.11 and higher
```

## Installation
```text
pip install django-carpet
```


## ENV
The `env` checks the execution mode and deployment status of the application and contains the following functions:
- `exec_mode` -> Gets the execution mode of the application. The options are `normal`, `test`, and `e2e` (accessed through `EnvChoices`)
- `is_debug` -> Checks the `DEBUG` constant in `settings.py`
- `is_production` -> Checks if the application is in the production mode. For the application to be in production mode, the `DEBUG` has to be false and `exec_mode` should be normal
- `is_testing` -> Checks if the application is in unit test or e2e test

In order for these functions to behave as intended, you need 3 settings to differentiate between the three execution modes. The execution mode is determined using `EXEC_MODE` constant. If no such constant is provided, the default value is `normal`. The name of the files is up to you:
- `settings.py`: The settings for the production. The `DEBUG` must be set to false.
- `settings_dev.py`: The settings for the development mode. This setting sets the DEBUG to false and detects if we are `test` command. It should have the following:
```python
DEBUG = True
if 'test' in sys.argv:
    EXEC_MODE = "test"
```
- `settings_e2e.py`: The settings for the E2E tests, allowing you to differentiate between the E2E tests and normal dev server. It should contain the following:
```python
DEBUG = True
EXEC_MODE = "e2e"
```