Saravanan666/pypi-org huggingface dataset:
Package: dot-net-core-uninstaller
Uninstall .Net Core SDK and RuntimeUninstall previous .Net Core SDK's and its runtime files.Note: You might need super user account to use this library.Instillationpip install dot-net-core-uninstallerUsageThere are to ways to use this:Using Command Line Interface (recommended)Usage: dotnetcore [OPTIONS] COMMAND [ARGS]...

Options:
  --version  Show version and exit.
  --help     Show this message and exit.

Commands:
  list    List all the version of .Net Core installed.
  remove  Remove the version of .Net Core.To list all installed .Net Core libraries> dotnetcore listUsing with POSIX systemsTo remove a version of .Net Core SDK or Runtimes:> dotnetcore remove --sdk 1.0.0
> dotnetcore remove --runtime 1.0.0Using with Windows systemsNote: Windows doesn't support removing runtime libraries individually from the uninstaller.To remove a version of .Net Core SDK or Runtime:> dotnetcore remove --sdk 1.0.0Using as a Modulefromdot_net_core_uninstallerimportUninstallerremove_dotnet=Uninstaller()remove_dotnet.delete_runtime("1.0.0")# Does not work on Windowsremove_dotnet.delete_sdk("1.0.0")# Does not work on Windowsremove_dotnet.delete_sdk_runtime_windows("1.0.0")# Does not work on POSIX
Package: dotnet-deptree
.NET Dependency Tree GeneratorCreate dependency tree visualizations for .NET projects.FeaturesGenerate dependency tree visualizations for one or more .NET projects.Supports rendering to SVG, PNG, PDF, and DOT formats.Visualize your local project dependencies alone, your package dependencies alone, or both together.Installpipinstalldotnet-deptreeUsage$ dotnet-deptree --help
usage: dotnet-deptree [-h] [--format {svg,png,pdf,dot}] [--exclude-projects]
                      [--exclude-packages] [--output OUTPUT] [--open]
                      project_paths [project_paths ...]

Generate dependency tree visualizations as for .NET projects.

Can be used to visualize package and project dependencies for a single project or a collection of projects.

positional arguments:
  project_paths         Generate dependency tree visualizations for one or
                        more .NET projects.

options:
  -h, --help            show this help message and exit
  --format {svg,png,pdf,dot}, -f {svg,png,pdf,dot}
                        The format of the rendered output. One of: svg, png,
                        pdf, dot. Default: svg.
  --exclude-projects    Exclude local project references from the dependency
                        tree.
  --exclude-packages    Exclude package references from the dependency tree.
  --output OUTPUT, -o OUTPUT
                        rendered output filename. prints to stdout by default
  --open                Open the generated files in the default web browserContributingVisit theGitHub repositoryfor the latest source code.RequirementsPoetryPython >= 3.11graphvizClone this repositoryRunpoetry install
Package: dotnetfile
dotnetfiledotnetfileis a Common Language Runtime (CLR) header parser library for Windows .NET files built in Python. The CLR header is present in every Windows .NET assembly beside the Portable Executable (PE) header. It stores a plethora of metadata information for the managed part of the file.dotnetfileis in a way the equivalent ofpefilebut for .NET samples.The library provides an easy-to-use API, but also tries to contribute new methods to improve file detection. This includes the MemberRef hash (experimental) and the original and a modified version of TypeRef hash.The aim of this project is to give malware analysts and threat hunters a tool to easily pull out information from the CLR header. You don't need to be an expert in the CLR header and get lost in its specification to use this library. By using the API, you'll also learn how the header is structured and hopefully get a better understanding of this file type in general.Installationdotnetfilerequires Python >= 3.7 andpefile.PyPIYou can easily installdotnetfilewith pip:pip install dotnetfileLocal setupTo installdotnetfileas a module, please use the providedsetup.pyfile. This can be done with the help of Python:python3 setup.py installUsageTo usedotnetfile, all you have to do is to import the module and create an instance of the classDotNetPEwith the .NET assembly path as a parameter. A minimal example that prints out the number of streams of an assembly is shown below:# Import class DotNetPE from module dotnetfilefromdotnetfileimportDotNetPE# Define the file path of your assemblydotnet_file_path='/Users/<username>/my_dotnet_assembly.exe'# Create an instance of DotNetPE with the file path as a parameterdotnet_file=DotNetPE(dotnet_file_path)# Print out the number of streams of the assemblyprint(f'Number of streams:{dotnet_file.get_number_of_streams()}')You are invited to explore the example scripts:https://github.com/pan-unit42/dotnetfile/blob/main/examples/DocumentationThe full documentation can be found athttps://pan-unit42.github.io/dotnetfile/AuthorsThis project was started in 2016 with the development of the parser library for internal use at Palo Alto Networks. It was improved/extended with the interface library and open-sourced in 2022 by the following people:Bob Jung (parser library)Yaron Samuel (parser library)@yaron_samuelDominik Reichel (parser and interface libraries)@TheEnergyStoryThis project is a work in progress. If you find any issues or have any suggestions, please report them to the GitHub project page.
Package: dotnet-generate
Dotnet generateScript generator for dotnet core 2.xTool for making it easier to generate MVC and API controllers in Asp.NET Core applications.
Helps also with managing DB migrations and updates.InstallationI have tested it with Python 3.6 onlyInstall it via pip/pip3pip install dotnet-generate.ExamplesExamples executed in dotnet core 2.1 solution folder, with the following structure├── DAL
│   └── AppDbContext.cs
├── Domain
│   ├── BaseEntity.cs
│   ├── Contact.cs
│   ├── ContactType.cs
│   ├── Domain.csproj
│   ├── Identity
│   │   ├── AppRole.cs
│   │   └── AppUser.cs
│   └── Person.cs
└── WebApp
    ├── Startup.cs
    ├── Program.cs
    ...MigrationsTo make new migrations run:dotnet-generate migrate MigrationNameMigrate command has some additional options:-u,-updatefor updating DB to latest migration.-m,--mvcfor creating MVC controllers.-a,--apifor creating API controllers.-t,--trythis option runs the tool without actually executing any commands, instead it will print those commands to console.You can also combine these flags, for example you can generate shell script with all the commands as follows:dotnet-generate migrate MigrationName -umat > script.shWhich will produce the following script.shdotnetefmigrationsaddMigrationName--projectDAL--startup-projectWebApp
dotnetefdatabaseupdate--projectDAL--startup-projectWebAppcdWebApp/
dotnetaspnet-codegeneratorcontroller-namePersonsController-actions-mPerson-dcAppDbContext-outDirControllers--useDefaultLayout--useAsyncActions--referenceScriptLibraries-f
dotnetaspnet-codegeneratorcontroller-nameContactsController-actions-mContact-dcAppDbContext-outDirControllers--useDefaultLayout--useAsyncActions--referenceScriptLibraries-f
dotnetaspnet-codegeneratorcontroller-nameContactTypesController-actions-mContactType-dcAppDbContext-outDirControllers--useDefaultLayout--useAsyncActions--referenceScriptLibraries-fcd../cdWebApp/
dotnetaspnet-codegeneratorcontroller-namePersonsController-actions-mPerson-dcAppDbContext-outDirApi/Controllers-api--useAsyncActions-f
dotnetaspnet-codegeneratorcontroller-nameContactsController-actions-mContact-dcAppDbContext-outDirApi/Controllers-api--useAsyncActions-f
dotnetaspnet-codegeneratorcontroller-nameContactTypesController-actions-mContactType-dcAppDbContext-outDirApi/Controllers-api--useAsyncActions-fcd../Db updatingFor updating db rundotnet-generate updateMVC controllers.For generating MVC controllers rundotnet-generate mvcAPI controllers.For generating API controllers rundotnet-generate apiInstallation for local buildIf you want to make this tool better,
then you can make local releases like this:Fork/Clone this project.Navigate to project dir.Edit the code.Install the CLI tool.pip3 install --editable .Check that tool is installeddotnet-generate --helpIf everything works, make new pull request?Built withClick
Package: dotnet-stubs
Incomplete, and probably incorrect, stubs for .NETTestsPyPIActivityOtherInstallationdotnet-stubscan be installed from PyPI.To install withpip:$python-mpipinstalldotnet-stubsStubs are build using thedotnet_stub_builderthat ships alongside these stubs. Is has additional dependencies, which can be installed using thebuilderextra:$python-mpipinstalldotnet-stubs[builder]
Package: dotnetz
dotnetzAn implementation of some .NET patterns in PythonWARNING: This repo is in development. It was automatically generated withmkpylib. If you're reading this message, it means that I use this repo for my own purposes right now. It might not do anything at all; the default functionality isprint('TODO').If you really want to try it out, feel free. I recommend reading through the code and commit history to see if it does what you need, orask mefor status updates.Stay tuned!Installpython3 -m pip install -U dotnetzUsageimportdotnetzprint('TODO')LicenseMITContactA library byShawn Presser. If you found it useful, please considerjoining my patreon!My Twitter DMs are always open; you shouldsend me one! It's the best way to reach me, and I'm always happy to hear from you.Twitter:@theshawwnPatreon:https://www.patreon.com/shawwnHN:sillysaurusxWebsite:shawwn.com
Package: dotobject
DotObject v 1.3.1Dot Notation ObjectDot lets you define objects in dot notation format.You need to subclass Dot and define your own load and optionally save methods in order to use the dot notation object.BackgroundDot Notation object was originally designed to be the base library for a Redis client for Python. Thus the names ‘load’ and ‘save’ come from. The idea was to have python object that simply by writing obj.item=”value”, it sets the redis key “obj.item” with “value” value.
And as soon as it detects you are retrieving the value, it gets the latest version from Redis. But in the mean time, it gives you a lazy object till it actually needs the value from Redis.So the Dot notation object is basically a lazy object that once its “load” and “save” methods are defined, it will run those methods when the object is saved or retrieved.Parametersroot_nameString, Optional.It is used to overwrite the Dot object root name.int_starts_with: String, Optional. Default: iIt is used to idefntify integer parts since Python does not let integers as attributes.ReturnsA lazy object that will be evaluated when it is actually used.ExamplesDefining your own Dot>>> from dot import Dot
>>> class This(Dot):
...     def __init__(self, *args, **kwargs):
...         super(This, self).__init__(*args, **kwargs)
...         self.items = {}
...     def load(self, paths):
...         return {i: self.items[i] if i in self.items else "value %s" % i for i in paths}
...     def save(self, path, value):
...         self.items[path] = value
...Creating a Dot object>>> this = This()
>>> aa = this.part1.part2.part3.part4
>>> aa
<Lazy object: this.part1.part2.part3.part4>
>>> print(aa)
value this.part1.part2.part3.part4
>>> aa
value this.part1.part2.part3.part4Dot objects get evaluated in a batch>>> this = This()
>>> aa = this.part1
>>> aa
<Lazy object: this.part1>
>>> bb = this.part2
>>> bb
<Lazy object: this.part2>
>>> print(aa)
value this.part1
>>> aa
value this.part1
>>> bb
value this.part2Dealing with paths that have integers as a part>>> bb = this.part1.part2.i120
>>> bb
<Lazy object: this.part1.part2.120>
>>> print bb
value this.part1.part2.120Dealing with Dots like dictionary keys>>> cc = this['part1.part2.part4']
>>> cc
<Lazy object: this.part1.part2.part4>
>>> dd = this['part1.%s.part4' % 100]
>>> dd
<Lazy object: this.part1.100.part4>
>>> path = 'part1.part2'
>>> this[path] = 'This was set by a dynamic key.'
>>> this.path
This was set by a dynamic key.Saving Dots>>> this.part1.part2.part3.part4 = "new value"
>>> zz = this.part1.part2.part3.part4
>>> zz
new valueChanging Root name>>> class That(This):
...    pass
>>> that = That()
>>> aa = that.something
>>> print(aa)
value that.something
>>> bb = this.something
>>> bb
<Lazy object: this.something>Flushing cache>>> aa = this.part1
>>> print aa
value this.part1
>>> bb = this.part1 # reads from the cache
>>> this.flush()
>>> bb = this.part1 # Will evaluate this.part1 again
Package: dotpack
dotpackPython client for dotpack ( Eliteu Programable led matrix pack ).Installpip install dotpackUsagefrom dotpack import DotPackFeaturesTODOCreditsThis package was created withCookiecutterand theaudreyr/cookiecutter-pypackageproject template.History0.3.5 (2023-11-16)0.3.4 (2023-08-17)0.3.2 (2022-10-31)0.3.1 (2022-09-15)0.3.0 (2022-05-25)0.2.1 (2022-05-19)0.2.0 (2022-05-18)0.1.4 (2022-05-10)0.1.3 (2022-05-6)0.1.2 (2022-05-5)0.1.1 (2022-05-5)0.1.0 (2022-03-18)First release on PyPI.
Package: dotpack-tk
dotpackA simulator(tkinter-based) for dotPack. ( Eliteu Programable led matrix pack ).Installpip install dotpack_tkUsagefrom dotpack import DotPackFeaturesTODOCreditsThis package was created withCookiecutterand theaudreyr/cookiecutter-pypackageproject template.History0.3.1 (2022-09-15)0.3.0 (2022-05-25)0.2.1 (2022-05-19)0.2.0 (2022-05-18)0.1.4 (2022-05-10)0.1.3 (2022-05-6)0.1.2 (2022-05-5)0.1.1 (2022-05-5)0.1.0 (2022-03-18)First release on PyPI.
Package: dotpath
dotpathA simple module to access Python props using dotpath.Examplefromdotpathimportdotpath# A objectpets_dic={'pets':{'dog':{'name':'Billy','age':5,'friends':['Joe','Jack'],},'cat':{'name':'Joe','age':6,'friends':['Billy','Pop'],},},}dog_name=getpath(pets_dic,'pets.dog.name')# Returns Billycat_name=getpath(pets_dic,'pets.cat.name')# Returns Joe
Package: dotpkg
DotpkgA package manager for your dotfiles.Why Dotpkg?Lightweight: Pure Python 3.9 with no dependenciesJSON-configurable: Easy to write, includes a schema for code completionCross-platform: Runs on Linux, macOS and WindowsFlexible: Configurable target locations, ignore lists, rename rules and moreUsageFirst make sure to have Python 3.9+ installed. To create a dotfile package, set up a folder with the following layout (the top-level folder is assumed to be some folder, e.g. a Git repo, where you store all of your dotfiles):dotfiles
└─my-package
  ├─dotpkg.json
  ├─.some-dotfile-one
  ├─.some-dotfile-two
    ...A minimaldotpkg.jsonis structured as follows:{"name":"my-package","description":"Description of my package"}Navigating intodotfilesand runningdotpkg install my-packagewill then symlink.some-dotfile-oneand.some-dotfile-twointo your home directory.Note that when running on Windows, unprivileged users might not be able to create symlinks, a feature thatdotpkgrelies on. EnablingDeveloper Modein your Windows Settings (from an administrator account) will permit this. Also, you may need to substitutepython3 [path/to/dotpkg]fordotpkgsince Windows does not support Unix-style shebangs.Optionally, you can specify keys such asrequiresOnPathtoo, which will only install the package if a given binary is found on yourPATH(useful if your config targets some application). Additionally,targetDirconfigures the search path to symlink the files into some other directory than your home (dotpkgwill use the first directory that exists, this is useful to cross-platform packages).For example, a package that manages configurations for Visual Studio Code could look like this:{"name":"vscode","description":"Visual Studio Code settings and keybindings","requiresOnPath":["code"],"targetDir":["${home}/.config/Code","${home}/Library/Application Support/Code","${home}/AppData/Roaming/Code"]}A full JSON schema for thedotpkg.jsonmanifests can be foundhere.Note that you can add the schema to your VSCode settings to get autocompletion indotpkg.jsonfiles by specifyingjson.schemas:{"json.schemas":[{"fileMatch":["dotpkg.json"],"url":"https://raw.githubusercontent.com/fwcd/dotpkg/main/dotpkg.schema.json"}]}Alternatively, you can specify the schema individually in eachdotpkg.json:{"$schema":"https://raw.githubusercontent.com/fwcd/dotpkg/main/dotpkg.schema.json"}
Package: dotpla
dotpla: Django One Time Password Link AuthenticationThis app adds a new Authentication method to Django, which allows you to generate links with a one-time password so you can allow users to log in directly, without having to define a password. It isnotan implementation of two-factor authentication (2FA).StatusWarning:this project is currently in development, and only supports Wagtail, for now. It is likely to change as/if I have time, but I am developing it primarily for my own uses, so it may not always be the highest priority.Rationale and Use CasesThis app can be used to share data with selected users from the deep web, without requiring them to register or login. You can create the user account for them, generate a one-time password, and send them a link that will log them in automatically. This allows you to protect data from unauthorized access, but also makes it easy for end-users to access it.Some potential use cases:Share a tailored version of your CV or cover letter with potential employers.Write a tailored sales pitch for potential customers.Share files with select users.InstallationPre-requirementsDjango 3.2 or greater.Python 3.8 or greater.TheDjango Messages Frameworkmust be enabled for your project if you want passwords to be displayed in the admin interface.Optional:Wagtail CMS. Tested with Wagtail 4.0.UsageTODO.CaveatsTheauthenticate_with_otpmethod has potential race conditions allowing users to log in more times than they should. As I only use this with trusted users, it's insignificant enough for me to ignore.
Package: dotplot
IdeaDotplot is a plot used mainly in biology for graphical visualisations of
sequences’ similarity. [Read more on Wikipedia]
(https://en.wikipedia.org/wiki/Dot_plot_%28bioinformatics%29).Why to create a new package?There are many programs that attempt to create dotplots already.
Unfortunately most of these programs was created long time ago and
written in old versions of Java. This Python3 package will allow new
generations of bioinformaticians to generate dotplots much easier.Installation & usageInstalation with pipThe easiest way to install this package with all dependencis is to use
pip:pipinstalldotplotManual installationgitclonehttps://github.com/kn-bibs/dotplotTo use graphical user interface, you will need to have pyqt5 installed,
e.g. with:sudoapt-getinstallpython3-pyqt5To use matplotlib for drawing, you need to have it installed, e.g. with:sudopip3installmatplotlibNote: If you have chosen manual installation, usepython3 dotplotcommand to run the program (while in thedotplotdirectory) instead
of soledotplot.Basic usagedotplot--fasta1.fa2.faTo use graphical user interface, type:dotplot--fasta1.fa2.fa--guiYou can also fetch sequences from various sources (at once):dotplot--gui--ncbiNP_001009852--uniprotP03086Advanced optionsYou can set window size to be used in plot creation:dotplot--fasta1.fa2.fa--gui--window_size2Furthermore, you can combine it with stringency:dotplot--fasta1.fa2.fa--gui--window_size2--stringency2And you can use a similarity matrix to compare aminoacids:dotplot--fasta1.fa2.fa--gui--window_size2--stringency2--matrixPAM120Getting helpTo access list of available options run command above with added option-h.What will it do?In the future our application will be able to read a wide range of input
formats, and users will be able to parametrize alignment process and
output format to their liking.Dependencies & developmentWe are writing inPython3and strict on code styling, with pep8 and
pylint validation. We require all code merging to master to have at
least 7,5 pylint score. To check this, at first install pytlint with
pip3 and then, run the following command:python3-mpylint dotplot.py, where in place ofdotplot.pyuse
any name of the module to be tested.
Package: dotplotlib
Great things come in tiny packages. A bare minimum extension library for creating tree dot plots, strip plots or dot charts w/ matplotlib or seaborn in PythonDesigned to work withmatplotlibandseabornin PythonFully customizableinstallationpip install dotplotlibusagedotplotlibcan be used to generate dot charts with minimal code. Here are some examples:Example 1: Simple Dot Chart.dotchartreturnsxandylists that can be inputted straight intomatplotliborseabornscatterplots.fromdotplotlibimportdotchartimportmatplotlib.pyplotaspltdata={'size':[1,2,2,3,3,3,4]}# Generate dot chart datax,y=dotchart(data['size'])# Plotplt.scatter(x,y)plt.show()Example 2: Dot Chart with Color MappingPass the data you would like to color by to thecolor_by=argument.Returns an extra listcthat should be passed into thec=parameter if usingmatplotliborhue=if usingseaborn.fromdotplotlibimportdotchartimportmatplotlib.pyplotaspltdata={'size':[1,2,2,3,3,3,4],'rating':[3,2,5,4,3,6,4]}# Generate dot chart data with color mappingx,y,c=dotchart(data['size'],color_by=data['rating'])# Plot with color mappingplt.scatter(x,y,c=c,cmap='viridis')plt.colorbar()plt.xlabel('Size')plt.ylabel('Number')plt.title('Mushroom Size Count Colored by Rating')plt.show()Example 3: Usingmake_dotchartto plot in one stepInstead of just giving youx, ylists to make the plot yourself,make_dotplot()actually generates the plot.fromdotplotlibimportmake_dotchartdf={'size':[1,2,2,3,3,3,4],'rating':[3,2,5,4,3,6,7]}# Create a dot chart with optional arguments (only the first one is mandatory)make_dotchart(df['size'],color_by=df['rating'],# list to color byreverse=False,# inverts the color mappingtheme='gnuplot2',# scroll down to see all themescolorbar=True,xlabel='Sizes',ylabel='Size Count',title='Mushroom Sizes Colored by Rating',dot_size=40):Example 4: Plotting in a Jupyter NotebookIf plotting inline, use the default.dotchart()to obtainxandylists, and then adjust as necessary with one of the following:plt.figure(figsize=(12,6))# orplt.figure().set_figwidth(12)# orplt.figure().set_figheight(12)preset themescustom:lavendercmapAny cmap value supported by matplotlib (see here) will work when passed intotheme='viridis'.viridis:gnuplot:gallery:featuresgenerate strip plots/dot charts by exploitingmatplotlib/seabornscatterplotssupports any cmap color profilethe data can be automatically sorted for better visualization, especially when using color mapping.accepts both list and pandas.Series as input data.set custom labels, titles, and dot sizes for your charts.works with Jupyter Notebookattributionpjarzabekm3ddlegal
Package: dotpruner
DotPrunerPruning redundant nodes from DOT graphsBefore:After:InstallationTo install DotPruner with pip, run:pip install dotprunerTo install DotPruner from source, first clone the repository and then run:python setup.py installUsageCLIPrune graph "in-place":python-mdotprunerpath/to/original/graph.dotUse--destor-dto specify destination for new graph:python-mdotprunerpath/to/original/graph.dot--destpath/to/new/graph.dotUse--overwriteor-oto overwrite existing file in destination:python-mdotprunerpath/to/original/graph.dot-dpath/to/new/graph.dot--overwriteAPIimportdotpruner# string representation of DOT graphoriginal_graph_str=...# pruned graph represented using pydotpruned_graph=dotpruner.process_from_string(original_graph_str)Optionally pass in anode_pickerfunction
to change which node is preserved in the pruning stage --
by default, the lexicographically smaller node is preserved.# keep the lexicographically larger nodedotpruner.process_from_string(original_graph_str,node_picker=max)Testspython-munittestdiscoverdotpruner.tests--verbose