Saravanan666/pypi-org huggingface dataset:
Package: ddir
ddirddiris a command line tool to calculate diffs between two directories and
resolve them.Check out thediff file formatas well.Installationpip install ddirThis will install a binary calledddiron yourPATHthat you can execute.
Depending on your system, you may need sudo/admin permissions.UsageUsage: ddir <commands>

Available commands:
    help                                - show this help
    version                             - show version
    init                                - initialize a source directory
    diff create <name>                  - create a diff for a target
    diff resolve <name> --modes <modes> - resolve a diff for a target
    diff list <name>                    - list all diffs for a target
    target create                       - create a target in interactive mode
    target list                         - list all targets
    target delete <name>                - delete target
    legacy migrate                      - migrate from legacy ddirFast modeIf you just want to compare change dates of files and not their content
(md5 hash), you can use the fast mode. Set that option when creating a target.Modes to resolveThe modes work like this: for each type (the order is+,-,>,<,?)
a number in the tuple indicates how to handle diffs of that type. There are
the following modes:0: skip1: apply (type dependent, see below)2: choose manuallyWhen choosing to apply diffs, the following will happen:+,>,?: override destination element with source element<: override source element with destination element-: delete destination elementThe diff file formatA diff file stores the differences between a file or a directory at a source
compared to a destination.SpecificationWe call a file or a directory anelement. The type of one element is eitherdfordirectoryorfforfile.We differentiate between five diff types:+(positive diff): an element exists in the source but not the
destination-(negative diff): an element exists in the destination but not
the source>(newer diff): the source element is newer than the destination element<(older diff): the source element is older than the destination element?(unknown diff): the elements are somehow different, but we can't
categorize them; used if files differ but change dates are equal; requires
manual resolutionThe diff file is a newline-separated text file with each line containing an
individual diff. Each line has the format:{diff type}:{element type}:{first element}:{second element}
Package: ddisasm
Datalog DisassemblyDDisasm is afastdisassembler which isaccurateenough for the
resulting assembly code to be reassembled.  DDisasm is implemented
using the datalog (souffle)
declarative logic programming language to compile disassembly rules
and heuristics.  The disassembler first parses ELF/PE file information
and decodes a superset of possible instructions to create an initial
set of datalog facts.  These facts are analyzed to identifycode
location,symbolization, andfunction boundaries.  The results of
this analysis, a refined set of datalog facts, are then translated to
theGTIRBintermediate
representation for binary analysis and reverse engineering.  TheGTIRB pretty printermay then be used to pretty print the GTIRB to reassemblable assembly
code.Binary SupportBinary formats:ELF (Linux)PE  (Windows)Instruction Set Architectures (ISAs):x86_32x86_64ARM32ARM64MIPS32Getting StartedYou can run a prebuilt version of Ddisasm using Docker:dockerpullgrammatech/ddisasm:latestDdisasm can be used to disassemble a binary into theGTIRBrepresentation.
We can try it with one of the examples included in the repository.First, start the Ddisasm docker container:dockerrun-v$PWD/examples:/examples-itgrammatech/ddisasm:latestWithin the Docker container, let us build one of the examples:aptupdate&&aptinstallgcc-ycd/examples/ex1
gccex.c-oexNow we can proceed to disassemble the binary:ddisasmex--irex.gtirbOnce you have the GTIRB representation, you can make programmatic changes to the
binary usingGTIRBorgtirb-rewriting.Then, you can usegtirb-pprinter(included in the Docker image) to produce
a new version of the binary:gtirb-pprinter ex.gtirb -b ex_rewrittenInternally,gtirb-pprinterwill generate an assembly file and invoke the compiler/assembler (e.g. gcc)
to produce a new binary.gtirb-pprinterwill take care or generating all the necessary command line
options to generate a new binary, including compilation options, library dependencies, or version linker scripts.You can also usegtirb-pprinterto generate an assembly listing for manual modification:gtirb-pprinterex.gtirb--asmex.sThis assembly listing can then be manually recompiled:gcc-nostartfilesex.s-oex_rewrittenPlease take a look at ourdocumentationfor additional information.DocumentationContributingSeeCONTRIBUTING.mdExternal ContributorsProgramming Language Group, The University of Sydney: Initial support for ARM64.Github user gogo2464: Documentation refactoring.CiteDatalog Disassembly@inproceedings {flores-montoya2020,
    author = {Antonio Flores-Montoya and Eric Schulte},
    title = {Datalog Disassembly},
    booktitle = {29th USENIX Security Symposium (USENIX Security 20)},
    year = {2020},
    isbn = {978-1-939133-17-5},
    pages = {1075--1092},
    url = {https://www.usenix.org/conference/usenixsecurity20/presentation/flores-montoya},
    publisher = {USENIX Association},
    month = aug,
}GTIRB@misc{schulte2020gtirb,
    title={GTIRB: Intermediate Representation for Binaries},
    author={Eric Schulte and Jonathan Dorn and Antonio Flores-Montoya and Aaron Ballman and Tom Johnson},
    year={2020},
    eprint={1907.02859},
    archivePrefix={arXiv},
    primaryClass={cs.PL}
}
Package: ddiscord
ddiscord: debugger for discord.pyPowered bydiscord.py.
This helps you write code for discord.py and manage your server via one-liner programs.
Tested on discord.py v1.0.0 but in theory it works on v0.16.7 and above.Usage$ ddiscord
 - Debugger for discord.py -
Running on Python 3.7.2. Send EOF (Ctrl-D) to exit.
Logged in as YourBot#0000 (012345678901234567)
You can refer to your Client instance as `client` variable. i.e. client.guilds

>>> len(client.guilds)
1
>>> client.user.bot
True
>>> await client.guilds[0].create_text_channel('test')
<TextChannel id=012345678901234567 name='test' position=1>
>>> for channel in client.get_all_channels():
...     if channel.name == 'test':
...         await channel.send('announcement test!')
... 
>>>Installation$ python3 -m pip install ddiscordLogging OnThere are four ways to log into your bot in ddiscord. They are listed below in look up order.Passing your token as an argument.Passing your token via standard input.-is needed as a first argument.Storing your token in a file namedtokenin the current directory.Passing your token via environment variableDISCORD_TOKEN.Run ddiscord first, then ddiscord will ask you the token.Examples:$ ddiscord 'YOUR TOKEN HERE'
$ echo 'YOUR TOKEN HERE' | ddiscord -
$ echo 'YOUR TOKEN HERE' >token; ddiscord
$ env DISCORD_TOKEN='YOUR TOKEN HERE' ddiscord
Package: ddlk
DDLK: Deep direct likelihood knockoffsThis package implements DDLK, a method for variable selection with explicit control of the false discovery rate.
Install with:pip install ddlkControlled variable selection with DDLKSuppose you have a set of features and a response.
DDLK identifies the features most predictive of the response at a pre-specified false discovery rate (FDR) threshold.
For example, if you choose an FDR of 20%, DDLK can guarantee that no more than 20% of the selected features will be unimportant.
To learn more about how it works, check outour paper.Running DDLKVariable selection with DDLK involves three stages:Fit a joint distribution to model featuresFit a knockoff generatorSample knockoffs and applyknockoff filterto select variables at a pre-specified FDRTo see a complete working example, check oursynthetic data example, used to generate the gif above.
Below is an exceprt of how to run DDLK.Fitting a joint distributionThis implementation of DDLK uses the fast and easyPyTorch Lightning frameworkto fitq_joint:# initialize datax,y=...# put your data in standard PyTorch formattrainloader=...# initialize joint distribution model with mean and std of data((X_mu,),(X_sigma,))=utils.get_two_moments(trainloader)hparams=argparse.Namespace(X_mu=X_mu,X_sigma=X_sigma)q_joint=mdn.MDNJoint(hparams)# create and fit a PyTorch Lightning trainertrainer=pl.Trainer()trainer.fit(q_joint,train_dataloader=trainloader)Fitting a knockoff generator# initialize and fit a DDLK knockoff generatorq_knockoff=ddlk.DDLK(hparams,q_joint=q_joint)trainer=pl.Trainer()trainer.fit(q_knockoff,train_dataloader=trainloader)Variable selectionUsing the knockoff generator, we sample knockoffs, and run aHoldout Randomization Test:xTr_tilde=q_knockoff.sample(xTr)knockoff_test=hrt.HRT_Knockoffs()knockoff_test.fit(xTr,yTr,xTr_tilde)Citing this codeIf you use this code, please cite the following paper (available here):Deep Direct Likelihood Knockoffs
M. Sudarshan, W. Tansey, R. Ranganath
arXiv preprint arXiv:2007.15835Bibtex entry:@misc{sudarshan2020deep,
    title={Deep Direct Likelihood Knockoffs},
    author={Mukund Sudarshan and Wesley Tansey and Rajesh Ranganath},
    year={2020},
    eprint={2007.15835},
    archivePrefix={arXiv},
    primaryClass={stat.ML}
}
Package: ddlogger
# Dot Dot LoggerPrints dots to stdout to log the progress of a loop without knowing the total loops.## Usage```pythonfrom ddlogger import ddloggerdef a_finite_generator():# ...# yield somethingwith ddlogger() as dl:for item in a_finite_generator():# do something that does not contain "print" statement/functiondl.update()  # prints a dot```Suppose in the above example the `a_finite_generator` returns an iterable of length 100, then it produces....................................................................................................where each row contains at most 79 dots. To change the number of dots in a row or the shape of the dots, see `help(ddlogger.DotDotLogger)`.## Installation```bashpip install ddlogger```or```bashpip3 install ddlogger```
Package: ddlogs
ddlogs=======[![Version](https://img.shields.io/pypi/v/ddlogs.svg)](https://pypi.python.org/pypi/ddlogs)# DescriptionDatadog logs logging handler and utilities.# Requirements- Python3.6 or higher- pip# Installation## PyPI```shpip install ddlogs```# Usage```pythonimport loggingimport ddlogslogger = logging.getLogger('test')h = ddlogs.DatadogLogsHandler(api_key='your-datadog-api-key',     # default: os.environ.get('DD_API_KEY')source_category='samplecategory',   # default: "ddlogs"source='samplesource',              # default: "python"service='sampleservice',            # default: logger.namehost='localhost')                   # default: gethostname()h.setFormatter(ddlogs.DictFormatter())logger.addHandler(h)logger.error({'foo': 'bar'})```# Output![screenshot](https://raw.githubusercontent.com/marcy-terui/ddlogs/master/images/screenshot.png)Development------------   Source hosted at [GitHub](https://github.com/marcy-terui/ddlogs)-   Report issues/questions/feature requests on [GitHubIssues](https://github.com/marcy-terui/ddlogs/issues)Pull requests are very welcome! Make sure your patches are well tested.Ideally create a topic branch for every separate change you make. Forexample:1.  Fork the repo2.  Create your feature branch (`git checkout -b my-new-feature`)3.  Commit your changes (`git commit -am 'Added some feature'`)4.  Push to the branch (`git push origin my-new-feature`)5.  Create new Pull RequestAuthors-------Created and maintained by [Masashi Terui](https://github.com/marcy-terui) (<marcy9114@gmail.com>)License-------MIT License (see [LICENSE](https://github.com/marcy-terui/ddlogs/blob/master/LICENSE))
Package: ddlparser
Project : SondeshDescriptionSondesh is the name of my cat . I love him very much
so i've decided to name this project after him.This project is all about a parser and comparator .
Question is what it is parsing ?It parse SQL statements , but only DDL statementsIt supports many sql dialects , example oracle , postgresql , sparksql , hive ..There is a cli app ( cli_app.py ), it compares two DDL statements and show you the differences in terminalHow to use the cli app ?python cli_app.pyThen just follow the instruction in the terminalYou either paste the raw sql or paste any absolute / relative path of sql fileDependenciesWindows 10 , Debian , BSD these are the supported platformPython version >=  3.8Installingddl_compare can be installed using pippip install ddl-parseUsagefromddlparserimportddl_parserimportpprintresult=ddl_parser.parse_from_file('/home/koushik/sample_ddl.sql')pprint.pprint(result)Using the CLI APP .Just Open the Terminaltype sondeshVOALAA !!!!!What Next :Integration to remote file system to load .sql from there and parse itIntegration with data-catalogues like spark catalogue or hive metastore and compare ddl.
Package: ddl-print
DDL PrintDDLPrint is a Django app that prints the DDL of your models without connecting to an actual database, and without relying on your migrations.InstallationInstall theddlprintpackage:pipinstallddlprintConfigurationAddddl_printto your Django project'sINSTALLED_APPSinsettings.py:INSTALLED_APPS=[...,'ddl_print',...]UsagePrint the DDL using your default DB driver by running theddlmanagement command:pythonmanage.pyddlYou can specify a specific DB driver by passing the alias to the --db_alias flag. You can find more info on how to set up different DB drivers herehttps://docs.djangoproject.com/en/5.0/ref/databases/.pythonmanage.pyddl--db_aliasmycoolalias
Package: ddlsplit
ddlsplitSplits a DDL file generated bypgModelerinto single files by database objects (schema, extension, table etc.).
Comments on Tables are parsed as multiline top-level comments,
which can be utilized bysphinx-sql(fork ofjackscodemonkey's sphinx-sql).Installationpip install ddlsplitUsageRun as a programddlsplit<ddl.sql><output-dir>Or clone this repo and run the program withpoetryfrom the cloned repository without installation:poetryinstall
poetryrunddlsplit<ddl.sql><output-dir>Use as a moduleMake sure,ddlsplitis in your$PATHor project's namespace!importddlsplitddl_code='''...'''Reverse Engineering A Database & Its DocumentationpgModeler → ddlsplit → sphinx w/ sphinx-sqlIf you maintain your database model with a graphical data modeling tool like pgModeler,
you can build a pipeline to automatically build your documentation withsphinx-sql,
e.g. by callingpgModelerandddlsplitfrom your sphinx' Makefile.This approach lets you keep the documentation of your SQL code inside the code itself,
thus reducing overhead costs by keeping code and documentation residing in multiple places in sync.# Optional: Reverse engineering an existing database:pgmodeler-cli\-platformoffscreen\--export-to-file\--import-db\--ignore-errors\--conn-aliaslocal-db\--input-dbdemodb\--outputdemo.sql\--pgsql-ver12.0# Export pgModeler's dbm to sql file:pgmodeler-cli\-platformoffscreen\--export-to-file\--inputdemo.dbm\--outputdemo.sql\--pgsql-ver12.0Example for top level comment for a table with pgModeler:Purpose:
This a new table to show how auto documentation can add new objects quickly.
Dependent Objects:
	Type	|	Name
	Schema	|	my_test_schema
ChangeLog:
	Date	|	Author	|	Ticket	|	Modification
	2020-12-26	|	Developer_2	|	T-247	|	Initial DefinitionResults in:COMMENTONTABLEpublic.findISE'Purpose:\nThis a new table to show how auto documentation can add new objects quickly.\nDependent Objects:\n\tType\t|\tName\n\tSchema\t|\tmy_test_schema\nChangeLog:\n\tDate\t|\tAuthor\t|\tTicket\t|\tModification\n\t2020-12-26\t|\tDeveloper_2\t|\tT-247\t|\tInitial Definition';Developingpoetryinstall
poetrybuildContributing
Package: ddn
DictDefaultNoneGet data from nested lists and dictionaries use Simple syntax, if can‘t return None, no raise IndexError or KeyError
用简单的python语法快速获取嵌套列表或者字典里的数据，如果没取到则返回空，而不是抛出IndexError或者KeyErroreg.: dict1["k1"]["k2"][0]["k"]fromddnimportDDNdata={"data":[{"key1":"123","key2":{"kkey1":{"kkkey1":"1234","kkkey2":12345}}},{"key1":"'1234'","key3":{"kkey1":{"kkkey1":"1234","kkkey2":True}}}]}d=DDN(data)ifres1:=d['data'][1]["key3"]["kkey1"]['kkkey1']:# '1234'print('ok',res1)ifnot(res2:=d['data'][88]["user"]["username"]['firstname']):# ''print('no',res2+'1234')print(DDN({13:1})+{23:4})# {13: 1, 23: 4}print(DDN({13:1})+'123123',type(DDN({13:1})+'123123'))# {13: 1}123123 <class 'str'>
Package: ddn3
DDN 3.0We developed an efficient and accurate differential network analysis tool – Differential Dependency Networks (DDN).
DDN is capable of jointly learning sparse common and rewired network structures, which is especially useful for genomics, proteomics, and other biomedical studies.
DDN 3.0 significantly improves the speed of previous verions of DDN, and is available as a Python package.
This repository provides the source code and examples of using DDN.InstallationOption 1: install into a new Conda environment using pipOne way is to install DDN into a new Conda environment. To create and activate an environment namedddn, run this:condacreate-nddnpython=3.11
condaactivateddnPython 3.12 may have some issue with Numba.DDN 3.0 can then be installed with the followin command.pipinstallddn3Option 2: install into an existing Conda environmentIf you want to install DDN into an existing Conda environment, it is suggested to install dependencies from Conda first.First we need to install some common dependencies.$condainstall-cconda-forgenumpyscipynumbanetworkxmatplotlibjupyterscipypandasscikit-learnThen runpipinstallddn3Alternatively, you can clone the repository, or just download or unzip it. Then we can install DDN 3.0.$pipinstall./Or you may want to install it in development mode.$pipinstall-e./UsageThis toy example generates two random datasets, and use estimate to estimate two networks, one for each dataset.importnumpyasnpfromddnimportddndat1=np.random.randn(1000,10)dat2=np.random.randn(1000,10)networks=ddn.ddn(dat1,dat2,lambda1=0.3,lambda2=0.1)For more details and examples, check thedocumentation, which includes three tutorials and the API reference.
The tutorials can also be found in thedocs/notebooksfolder.TestsTo run tests, go to the folder of DDN3 source code, then runpytest.pytesttestsIt will compare output of DDN with reference values. It tests DDN with various acceleration strategies.ContributingPlease report bugs in the issues.
You may also email the authors directly: Yizhi Wang (yzwang@vt.edu), Yingzhou Lu (lyz66@vt.edu), or Yue Wang (yuewang@vt.edu).
If you are interested in adding features or fixing bug, feel free to contact us.LicenseTheddnpackage is licensed under the terms of the MIT license.Citations[1] Zhang, Bai, and Yue Wang. "Learning structural changes of Gaussian graphical models in controlled experiments." arXiv preprint arXiv:1203.3532 (2012).
Package: ddna
DDNAProgram / Library that converts sentences to DNA sequence and vice-versa.OoOoOoAOo|AOo||OoG|GO|C1|OG|T|O|11oO|ToOA|oOCoOoOoOInstallation:pipinstallddnaUsage:programpython3 -m ddna -h    
usage: ddna.py [-h] [-e ENCODE] [-d DECODE]

DDNA - DNA Encoder/Decoder

optional arguments:
  -h, --help            show this help message and exit
  -e ENCODE, --encode ENCODE
                        Encode String to DNA
  -d DECODE, --decode DECODE
                        Decode DNA to Stringpip package>>> from ddna import DDNA
>>> DDNA().encode("HELLO WORLD")
'CAGACACCCATACATACATTAGAACCCTCATTCCAGCATACACA'
>>> DDNA().decode("CAGACACCCATACATACATTAGAACCCTCATTCCAGCATACACA")
'HELLO WORLD'Plans:Introduce MutationsIntroduce new form of encryption based on mutations
Package: ddnp
DDNP: Docker Data Network ProxyUtility for providing data from the build host to the build process container.Check code (static analysis)pylint -d C0321,C0326,C0411,W0107,R1711 ddnpBuild docker containerexport DDNP_VERSION=1.0.1
docker build --build-arg VERSION=$DDNP_VERSION \
             --tag ddnp:${DDNP_VERSION} - < DockerfileRun locally (mainly for testing)PYTHONPATH=/home/niessner/Projects/DCP python3 -m ddnp -e /home/niessner/Projects/DCP/example.txt -v /tmp/test
Package: ddns-client
DDNS采用以下开源项目作为核心实现:CoreDNS:https://coredns.io/Etcd:https://etcd.io/获取公网IP接口(多个容错):http://www.myipaddress.com/show-my-ip-address/https://www.ipip.net/http://20019.ip138.com/日志/指标方案支持以下:fluentd:https://github.com/fluent/fluentdprometheus:https://github.com/prometheus/prometheusnetdata/statsd:https://github.com/netdata/netdata,https://github.com/statsd/statsd部署方案支持以下:systemd:https://github.com/systemd/systemddocker:https://github.com/moby/mobyk8s:https://github.com/kubernetes/kubernetes其他参数支持:pid客户端采用技术:python3.6:https://docs.python.org/3.6/logging/asyncio:uvloop:https://github.com/MagicStack/uvloopetcd:https://github.com/kragniz/python-etcd3fluentd:https://github.com/fluent/fluent-logger-python#使用tcp通信, 与架构兼容性不好fluentd:https://docs.fluentd.org/input/udpstatsd:https://github.com/jsocol/pystatsdprometheus:https://github.com/prometheus/client_pythonaiohttp:https://github.com/aio-libs/aiohttpcolor:https://github.com/tartley/colorama,https://github.com/xolox/python-coloredlogs实现方案考虑coredns + /etc/hosts + python server/clientcoredns + etcd + python client最终方案选择降低对环境的耦合, 不对/etc/hosts进行操作(简单性能一般), 最终采用coredns + etcd + python client方案。部署方案考虑支持以下方案(平台支持: linux/amd64+arm64):二进制/systemdDocker/docker-compose/docker-swarmk8s周边生态考虑支持以下项目:参数配置命令行参数:argparse环境变量:dotenv配置文件:yaml日志输出:标准输出/错误日志文件(根据信号支持重新打开):loggingfluentd输出:fluentd-python指标输出:http/https:prometheusnetdata/statsd:statsd-python信号处理:重启加载日志stop/quit/reopen/reload运行流程图读取配置文件:运行:安装部署# brotlipy(aiohttp[speedup]) requirementsaptinstall-ybuild-essentialpython3.6-devlibffi-dev
Package: ddns-for-aws
Tool to Sync your external IP address with an A Record in Route 53UsageInstall AWS CLI and add your credentialsRun “pip install -e .” in the programs parent directoryRun commmand ‘set-ddnsaws’ with DNS Name and Hosted Zone ID arguments.Or Configure JSON and run with just the command.Cronjob the command to run every 15 minutes.ExamplesExample to upload with CLI arguments:set-ddnsaws -DNSName "blog.example.com" -HostedZoneId "000aaa00"Example to upload config.josn arguments:set-ddnsaws