Saravanan666/pypi-org huggingface dataset:
Package: aid-hash
AIDThis package provides modified Python implementation of the openCommunity IDflow hashing standard that takes into consideration the flow timestamp.It supports Python versions 2.7+ (for not much longer) and 3+.InstallationThis package is availableon PyPI, therefore:pip install aid_hashTo install locally from a git clone, you can use also use pip, e.g. by sayingpip install -U .UsageThe API breaks the computation into two steps: (1) creation of a flowtuple object, (2) computation of the Community ID string on thisobject. It supports various input types in order to accommodatenetwork byte order representations of flow endpoints, high-level ASCII,and ipaddress objects.Here's what it looks like:import aid_hash

tpl = aid_hash.FlowTuple.make_tcp('14.125487','127.0.0.1', '10.0.0.1', 1234, 80)

aid =  aid_hash.AID()

print(aid.calc(tpl))This will print 2:7RJA0SqvF3nbfatPoP1dkZnVvWw=.CommunityID vs AIDAID is a modified version of Zeek's CommunityID.
The main purpose of it is to avoid the collisions
caused when CID groups flows that happened in different days together because they have common
srcip/dstip srcport/dstport and protofor example:if there's a flow from IP1:port1 -> IP2:port2 at 1AM 10/10/2023,
it will have the same community ID as a flow from IP1:port1 -> IP2:port2 at 9PM 10/10/2023 or even a week after.
which means that entirely different flows will have the same cid.The major difference is that AID
take into consideration the timestamp of the flow.
AID matches exact flows accross different monitors instead of correlating them.TestingThe package includes a unittest testsuite in thetestsdirectory
that runs without installation of the module. After changing into that
folder you can invoke it e.g. viapython3 -m unittest tests/aid_test.pyAcknowledgmentsThis is a fork of Zeek's Community ID, the code was originally written by Christian Kreibich @ckreibich
Package: ai-dialog-model
nlg-deeppavlov-apiset of NLG experimentation using deep pavlov libraryFree software: Apache Software License 2.0Documentation:https://nlg-deeppavlov-api.readthedocs.io.FeaturesTODOCreditsThis package was created withCookiecutterand theaudreyr/cookiecutter-pypackageproject template.History0.1.0 (2019-02-06)First release on PyPI.
Package: aidial-sdk
AI DIAL Python SDKOverviewFramework to create applications and model adapters forAI DIAL.Applications and model adapters implemented using this framework will be compatible withAI DIAL APIthat was designed based onAzure OpenAI API.UsageInstall the library usingpip:pip install aidial-sdkEcho application exampleThe echo application example replies to the user by repeating their last message:# Save this as app.pyimportuvicornfromaidial_sdkimportDIALAppfromaidial_sdk.chat_completionimportChatCompletion,Request,Response# ChatCompletion is an abstract class for applications and model adaptersclassEchoApplication(ChatCompletion):asyncdefchat_completion(self,request:Request,response:Response)->None:# Get last message (the newest) from the historylast_user_message=request.messages[-1]# Generate response with a single choicewithresponse.create_single_choice()aschoice:# Fill the content of the response with the last user's contentchoice.append_content(last_user_message.contentor"")# DIALApp extends FastAPI to provide a user-friendly interface for routing requests to your applicationsapp=DIALApp()app.add_chat_completion("echo",EchoApplication())# Run built appif__name__=="__main__":uvicorn.run(app,port=5000)Runpython3 app.pyCheckSend the next request:curlhttp://127.0.0.1:5000/openai/deployments/echo/chat/completions\-H"Content-Type: application/json"\-H"Api-Key: DIAL_API_KEY"\-d'{"messages": [{"role": "user", "content": "Repeat me!"}]}'You will see the JSON response as:{"choices":[{"index":0,"finish_reason":"stop","message":{"role":"assistant","content":"Repeat me!"}}],"usage":null,"id":"d08cfda2-d7c8-476f-8b95-424195fcdafe","created":1695298034,"object":"chat.completion"}Developer environmentThis project usesPython>=3.8andPoetry>=1.6.1as a dependency manager.Check out Poetry'sdocumentation on how to install iton your system before proceeding.To install requirements:poetry installThis will install all requirements for running the package, linting, formatting and tests.IDE configurationThe recommended IDE isVSCode.
Open the project in VSCode and install the recommended extensions.The VSCode is configured to use PEP-8 compatible formatterBlack.Alternatively you can usePyCharm.Set-up the Black formatter for PyCharmmanuallyor
install PyCharm>=2023.2 withbuilt-in Black support.LintRun the linting before committing:makelintTo auto-fix formatting issues run:makeformatTestRun unit tests locally for available python versions:maketestRun unit tests for the specific python version:maketestPYTHON=3.11CleanTo remove the virtual environment and build artifacts run:makecleanBuildTo build the package run:makebuildPublishTo publish the package to PyPI run:makepublish
Package: aidios-sdk
######Aidios SDK for Python#######This SDK for the AIDIOS API, provides an easy to use pyton interface. It allows you to retrieve and store data, get digest information, and confirm data transactions.#Installation
Using Pip:
pip install aidios_sdk#Dependencies
requests
json
(note json, and requests will be downloaded when you install aidios_sdk. 'requests' is only used in the example_usage.py#Usage
#Importing the SDK
First, import the SDK in your Python script:from aidios_sdk import AidiosAPI##Initializing the API Client
You can initialize the API client as follows:api = AidiosAPI()###Retrieve Data
To retrieve data, use the retrieve method and pass in the data ID:data_id = "some_data_id"
response = api.retrieve(data_id)
print("Retrieve Response:", response)####Store Data
Use the store method and pass a file:with open("path/to/file", "rb") as file:
file_content = file.read()data = {"file_content": file_content}
response = api.store(data)
print("Store Response:", response)#####Get Digest
To get digest information, use the digest method:data_id = "some_data_id"
response = api.digest(data_id)
print("Digest Response:", response)######Get Confirmations
Check this number of transactions and associated stats for a given (root)txid:transaction_id = "some_transaction_id"
response = api.confirmations(transaction_id)
print("Confirmations Response:", response)#######Example Script
An example script demonstrating these functionalities is included in the examples/ directory.To run the example:python examples/example_usage.pyThe test script will prompt you to perform each of the functions( store, retrieve, digest and confirmations.Have fun with aidios!
Package: aidkit
aidkit is the quality gate between machine learning models and the deployment of those models.InstallationActivate your virtual environment with python 3.6, e.g.source venv/bin/activatepip install aidkitExample UsageAuthenticateThe only requirement for using aidkit is having a license for it.To authenticate, you need to run the following once:python-maidkit.authenticate--url<subdomain>.aidkit.ai--token<yourauthtoken>ModelYou can upload a model to aidkit, or list the names of all models
uploaded.For uploading, you need a keras .h5 file, that contains a LSTM
architecture. Do the following to upload it:python-maidkit.model--file<pathtoyourh5file>To list all uploaded models type:python-maidkit.modelDataYou can upload a data set to aidkit, or list the names of all datasets
uploaded.For uploading, you need a zip file.
We expect a zip, containing a folder, that is named like the dataset
should be called. This subfolder contains INPUT and OUTPUT folders
that each contain csv files. Do the following to upload it:python-maidkit.data--file<pathtoyourzipfile>To list all uploaded datasets type:python-maidkit.dataAnalysisYou can start a new quality analysis. For doing so, you need a toml file.
This file will follow a specified toml standard. Do the following to upload it:python-maidkit.analysis--file<pathtoyourtomlfile>To list all uploaded datasets type:python-maidkit.analysisVisualizationAfter running an analysis you can observe the results in our web-GUI. to get the link type:python-maidkit.urlJust follow the link and authorize yourself with your credentials.
Package: aidkitcli
aidkit is the quality gate between machine learning models and the deployment of those models.InstallationActivate your virtual environment with python 3.6, e.g.source venv/bin/activatepip install aidkitExample UsageAuthenticateThe only requirement for using aidkit is having a license for it.To authenticate, you need to run the following once:python-maidkitcli.authenticate--url<subdomain>.aidkitcli.ai--token<yourauthtoken>ModelYou can upload a model to aidkit, or list the names of all models
uploaded.For uploading, you need a keras .h5 file, that contains a LSTM
architecture. Do the following to upload it:python-maidkitcli.model--file<pathtoyourh5file>To list all uploaded models type:python-maidkitcli.modelDataYou can upload a data set to aidkit, or list the names of all datasets
uploaded.For uploading, you need a zip file.
We expect a zip, containing a folder, that is named like the dataset
should be called. This subfolder contains INPUT and OUTPUT folders
that each contain csv files. Do the following to upload it:python-maidkitcli.data--file<pathtoyourzipfile>To list all uploaded datasets type:python-maidkitcli.dataAnalysisYou can start a new quality analysis. For doing so, you need a toml file.
This file will follow a specified toml standard. Do the following to upload it:python-maidkitcli.analysis--file<pathtoyourtomlfile>To list all uploaded datasets type:python-maidkitcli.analysisVisualizationAfter running an analysis you can observe the results in our web-GUI. to get the link type:python-maidkitcli.urlJust follow the link and authorize yourself with your credentials.
Package: aidkitHW
aidkitHWThis repo is for a coding challenge to interface various frameworks eg pytorch (fastai), tensorflow, onnx and inferencing onnx-runtime. The work is best followed on Linux OS with jupyter notebooks.Some prerequisites to follow along:pip install jupyter notebookIn case there's problems installing onnx:sudo apt-get install protobuf-compiler libprotoc-devTo useonnx-tensorflowfor tensorflow-1.x install it using:git clone https://github.com/onnx/onnx-tensorflow.git && cd onnx-tensorflow
git checkout tf-1.x
pip install -e .The package can be installed via pip:pip install aidkitHW
Package: aidoc
aidocaidoc is a command line interface (CLI) tool that uses AI to automatically generate documentation for your code.RequirementsOpenAI API key:https://beta.openai.com/Python 3.6 or higherInstallationglobally install the packagepython3 -m pip install aidoc(recommended) create a virtual environment and install the packagepipinstallaidocUsageTo configure the API key and model for aidoc, run the following command:aidoc configureTo generate documentation for a source file or directory, run the following command:aidoc gen <source_file>You can also specify the following optional arguments:-oor--overwrite: Overwrite existing docstrings-for--format: Format the entire source file using black (default=True)-pror--pull-request: Create a pull request with the changesExamplesGenerate docstrings for the main.py file:aidoc gen main.pyGenerate docstrings for all Python files in the src directory and its subdirectories:aidoc gen srcGenerate docstrings and create a pull request with the changes:aidoc gen main.py -prContributingPull requests are welcome. For major changes, please open an issue first to discuss what you would like to change.LicenseThis project is licensed under the GNU General Public License v3.0 - see theLICENSEfile for details.AcknowledgmentsOpenAIDisclaimerThis project is not affiliated with OpenAI. The OpenAI API and GPT-3 language model are not free. You will need to sign up for a freeOpenAIaccount and create an API key to use this tool.
Package: ai-dq-module
DQAI (Data Quality Artificial Intelligence)This code provides a Python class calledDQAIthat utilizes the OpenAI Chat API to analyze a dataset and generate data quality rules specific to the data.UsageInstall the necessary dependencies.Set up your OpenAI API key or use the provided default key.Prepare your dataset in a suitable format (e.g., CSV).Instantiate theDQAIclass.Invoke theinvoke_from_datasetmethod, passing the dataset as input.The code will generate Python code based on the dataset and execute it.The generated rules and the results will be saved in the current directory as "generated_code.py" and "rulesapplication.csv," respectively.The generated rules can be obtained by calling the_get_rules_from_filemethod.Note: Make sure to modify the file path (pathvariable) in the provided code to match your dataset's location.Example:import pandas as pd
from dqai import DQAIRead the dataset from a CSV filepath = "path/to/your/dataset.csv"
data = pd.read_csv(path)Instantiate DQAI and generate data quality rulesdqai = DQAI()
result = dqai.invoke_from_dataset(data)Access the generated rules and resultsrules = result["0"]
results_df = result["1"]
Package: ai-drf-core
Overview:This package contains various useful helper functions for the django REST framework.ATTENTION: This package is deprecated. All functionality will live on in theai-django-corepackage.
Please install it with the drf-extension enabled. More details in the changelog.Installation:Add a requirement to your requirements.txt:ai-drf-coreAdd module toINSTALLED_APPS:ai-drfRun migrationsContributeClone the project locallyCreate a new branch for your featureChange the dependency in your requirements.txt to a local (editable) one that points to your local file system:-e /Users/myuser/workspace/ai-drf-coreEnsure the code passes the testsRun:python setup.py developCreate a pull requestPublish to PyPIRun:python setup.py sdist uploadIf you run into trouble, please create a file in your home directory: ~/.pypirc[distutils]
index-servers =
    pypi

[pypi]
repository: https://upload.pypi.org/legacy/
username:
password:TestsCheck coveragepytest --cov=ai-drf-coreRun testspytest
Package: aids
AIDScrapperBased off a small script made by an Anonymous user. Now it's a full featured client which supports not onlyAIDbut alsoHolo. Alternatively, it can transform AID scenario objects in .scenario files for compatibility with the different AI Dynamic Storytelling platforms, speciallyNAIThe json files can be transformed into .html for better readability although that's not the main purpose of this tool - you should upload it to one of the supported websites to use the stories.RequirementsTo install all requirements, use the following snippet after installing python on your machine.pip install -r requirements.txtOr just use:pip install aidsUsageTo install the whole thing. You can manage it directly from console. Use:aids helpAfterwards for a list of commands or:aids-windows.bat helpIf you use Windows.You can also use the package directly via:python3 -m aids helpOr in outside the package directory with:python aids/manage.py helpTestingIf you feel like messing around with the code make sure none of the tests are failing using thetestcommand. It uses pytest if you have it installed or unittest as a fallback.
Package: aidsinfo
A Python wrapper for the AIDSinfo drug information API.AIDSinfo Documentation:http://www.aidsinfo.nih.gov/Other/rss.aspxUsage>>> from aidsinfo import DrugInfo
>>> info = DrugInfo()
>>> info.search('abacavir')
{'abacavir': {'data': 'here'}}>>> info.search('combivir')
{'combivir': {'data': 'here'}}>>> # You can also get back just the XML data.
... xml_data = info.search('combivir', output_format=None)CopyrightCopyright (c) 2011 Code for America Laboratories.See LICENSE for details.
Package: aidt
AI Data TransformersThis repo contains a library that uses LLMs for data transformations on values in Pandas or Spark dataframes.The core value prop is that the library exposes simple building blocks for writing transformations thta use LLM to perform some computation over the data as given by a prompt. In essence, instead of defining a data transformation logic in detailed code, we replace the logic with an LLM, i.e. we instruct the LLM to take an instruction and process and get the desired output from the data.For example, consider the problem for needing to parse out the data from raw text which can be in format: unix timestamp, UTC timestamp, textual description, in Japanese etc. Traditionally, data engineers need to write well-test transformation of ever-increasing subsets of cases on highly filtered data to do so. But you can do so with just an LLM call with the instruction: "parse out time and write it out as a UTC timestamp".The library exposes interfaces for both API-based models and open source models. In particular, once can take a possible quantized model and use that. The library takes care of optimially running it, the worker distribution and serialization.Low-Level Functions -> Let Pandas etc. handle itMap, Reduce, SerializeComposition Functions -> Let User Define themDon't define composition abstractions, let users handle it.Text Level Functionstransform(x, transform_instruction)
structify(x, model: PydanticBaseModel, structify_instruction=None)
classify(x, c, labels=[], classification_instruction=None)
score_in_range(x, range_start, range_end, scoring_instruction=None)
extract(x, types=[])OptimizationsCompile TransformationsFor a sequence of transformations, if you compile and serialize, under the hood, the models will reuse the KV-cache for the input.
Package: aidu
aiduArtificial Intelligence, DoLicenseApache Version 2.0Copyright 2019 Alexander W. Wong
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
Package: aidungeonapi
AIDungeonAPIUNOFFICIAL Api to interface with AI dungeonExamplefromaidungeonapiimportAIDungeonClientimportasyncioasyncdefcallback(result):print(result)asyncdefblocking_task():whileTrue:awaitasyncio.sleep(10)asyncdefmain():aidc=awaitAIDungeonClient(debug=True)adventure=awaitaidc.connect_to_public_adventure('51e86616-507f-49f7-b07d-9a58b3261781')awaitadventure.register_actions_callback(callback)awaitasyncio.create_task(blocking_task())asyncio.run(main())
Package: aiearth-predict
AI Earth Predict 是时空数据和AI模型相结合的开发套件，用于进行大规模遥感数据模型推理的统一计算库，并可以用来并行处理遥感数据，支持本地模式运行，以及将模型部署到 AI Earth地球科学云平台AI Earth Predict Github
Package: aiei
Install AIEIVersion is recommended, not requiredpython>=3.6torch>=1.6.0 (pytorch amp & tensorboard), torchvisioninstall locally:pip install -v -e .. With building ops:AIEI=0 pip install -v -e .change variable:base_config.py -> TORCH_MODEL_HOME, config.py -> data_pathTODOmerge multi-scale_pad and get_scale_padadd user define path_ckpt
Package: ai-einblick-prompt
ai-einblick-promptai-einblick-promptempowers JupyterLab users with a domain-specific AI agent that can generate, modify, and fix code for data science workflows. Einblick's extension is the easiest and only context-aware way to augment the data workflow with generative AI.Einblick Prompt AIEinblick is the AI-native data notebook that can write and fix code, create beautiful charts, build models, and much more. This is made possible via our domain-specific AI agent, Einblick Prompt. Visit ourhomepageto learn more about Einblick.UsageWatch a quick video tutorial.Quick StartStart JupyterLab and installai-einblick-promptvia the Extension Manager in the left panel.Read in a dataset.Click the Einblick logo icon in the top-right side of any Python cell, and select “Generate.”Ask Einblick Prompt AI to write code.Example Prompts“Create a box plot of col_3.”“Filter for cat_1, cat_2, and cat_3.”“Create a scatter plot of col_1 vs. col_2, color by col_4.”Keyboard shortcutCommand (⌘) + K/Ctrl + K- Toggle prompt widget on active cell.CommandsThe following commands are executable from the Jupyterlab command palette (Command (⌘) + Shift + C/Ctrl + Shift + C)Einblick AI: Prompt: Toggle prompt widget on active cell.Einblick AI: Generate: Toggle "Generate" prompt on active cell to create new code for the cell.Einblick AI: Fix: Toggle "Fix" prompt on active cell to fix errors in the cell.Einblick AI: Modify: Toggle "Modify" prompt on active cell to change existing code in the cell.Installation StepsRequirementsJupyterLab >= 4.0.0InstallMethod 1Searchai-einblick-promptin JupyterLab's Extension Manager, and click InstallMethod 2Execute:pipinstallai-einblick-promptUninstallTo remove the extension, execute:pipuninstallai-einblick-prompt
Package: ai-embedder
AI Link EmbedderIntroductionThis abomination of a code was created to solve my fiancé issue with migrating Adobe Illustrator files to different machine. It comes with absolutely no guarantee, but it seems to work. Good luck.RequirementsRunning this script requires:Windows OS (macOS is not supported for now)Adobe Illustrator installedRunUsage:usage: AI Link Embedder [-h] [-r] [-o] [-d DEST] [-p PREFIX] [-s SUFFIX]
                        dictionary

This script takes .ai files and save them with linked files embedded

positional arguments:
  dictionary            Directory with input .ai files

options:
  -h, --help            show this help message and exit
  -r, --recursive       Scan for .ai files recursively
  -o, --override        Override resulting .ai is it exists
  -d DEST, --dest DEST  Directory where resulting .ai files will be saved to
  -p PREFIX, --prefix PREFIX
  -s SUFFIX, --suffix SUFFIXExample:python -m ai_embedder
Package: aiengine
AIEngine is a next generation interactive/programmable Python/Ruby/Java/Lua packet inspection engine with capabilities of learning
without any human intervention, NIDS(Network Intrusion Detection System) functionality, DNS domain classification, network collector, network forensics and many others.AIEngine also helps network/security professionals to identify traffic and develop
signatures for use them on NIDS, Firewalls, Traffic classifiers and so on.The main functionalities of AIEngine are:Support for interacting/programing with the user while the engine is running.Support for PCRE JIT for regex matching.Support for regex graphs (complex detection patterns).Support five types of NetworkStacks (lan,mobile,lan6,virtual and oflow).Support Sets and Bloom filters for IP searches.Support Linux, FreeBSD and MacOS operating systems.Support for HTTP,DNS and SSL Domains matching.Support for banned domains and hosts for HTTP, DNS, SMTP and SSL.Frequency analysis for unknown traffic and auto-regex generation.Generation of Yara signatures.Easy integration with databases (MySQL, Redis, Cassandra, Hadoop, etc…) for data correlation.Easy integration with other packet engines (Netfilter).Support memory clean caches for refresh stored memory information.Support for detect DDoS at network/application layer.Support for rejecting TCP/UDP connections.Support for network forensics on real time.Supports protocols such as Bitcoin,CoAP,DHCP,DNS,GPRS,GRE,HTTP,ICMPv4/ICMPv6,IMAP,IPv4/v6,Modbus,
MPLS,MQTT,Netbios,NTP,OpenFlow,POP,Quic,RTP,SIP,SMTP,SSDP,SSL,TCP,UDP,VLAN,VXLAN.
Package: ai_engine_new
Name: AI-EngineDescription: Kandinsky-Dream-Image-API is a reverse API that provides a simple and efficient way to generate images using AI from Kandindy or Dream.ai .Dowloand:pip install ai_engineAlso, make sure you have Python version 3.8 or higher installed
Perhaps you use pydantic in your projects, you will not need to change the usual version, it works with two versions (from 1.12.10 to 2.3.0)
The library is small, easy to replenish. Poetry was used for developmentThe documentation will be written on the wiki pages, please fill it upFunctional:– Image generation using models from Kandinky and Dream.ai
– A simple and intuitive API for interaction
– The ability to configure image generation parameters (resolution, style, etc.)