Saravanan666/pypi-org huggingface dataset:
Package: ld
Theld(for: Linux Distribution) package provides information about the
Linux distribution it runs on, such as a reliable machine-readable ID, or
version information.It is a renewed alternative implementation for Python’s
originalplatform.linux_distributionfunction, but it also provides much more
functionality.
An alternative implementation became necessary because Python 3.5 deprecated
this function, and Python 3.7 is expected to remove it altogether.
Its predecessor functionplatform.distwas already deprecated since
Python 2.6 and is also expected to be removed in Python 3.7.
Still, there are many cases in which access to that information is needed.
See [Python issue 1322](https://bugs.python.org/issue1322) for more
information.Theldpackage implements a robust and inclusive way of retrieving the
information about a Linux distribution based on new standards and old methods,
namely from these data sources (from high to low precedence):The os-release file/etc/os-release, if present.The output of thelsb_releasecommand, if available.The distro release file (/etc/*(-|_)(release|version)), if present.## Installation`shell pip install ld `For dev:`shell pip installhttps://github.com/nir0s/ld/archive/master.tar.gz`## Python and Distribution SupportTheldpackage is supported on Python 2.6, 2.7, 3.4 and 3.5, and on
any Linux distribution that provides one or more of the data sources
used by this package.This package is currently tested on Python 2.6, 2.7 and 3.5, with test
data that mimics the exact behavior of the data sources of the following
Linux distributions:Arch LinuxCentOS 5/7Debian 8ExherboFedora 19/23KVM for IBM z Systems 1Mageia 5openSUSE Leap 42Oracle Linux Server 7RHEL 6/7Slackware 14SUSE Linux Enterprise Server 12Ubuntu 14## Usage` python >>> import ld >>> ld.linux_distribution(full_distribution_name=False)'('centos','7.1.1503','Core')'`Several more functions are available. For a complete description of the
API, see the [latest API documentation](http://ld.readthedocs.org/en/latest/).
Package: ld2410-ble
LD2410 BLEInterface with LD2410B modules from HiLinkInstallationInstall this via pip (or your favourite package manager):pip install ld2410-bleContributors ✨Thanks goes to these wonderful people (emoji key):This project follows theall-contributorsspecification. Contributions of any kind welcome!CreditsThis package was created withCookiecutterand thebrowniebroke/cookiecutter-pypackageproject template.
Package: ld4apps
LD4Apps is an Apache2 licensed Python library for Linked Data for Applications (LDA).
LDA helps you implement applications that will be part of a bigger coherent system, for
example a web-site made up of multiple applications that talk to each other. LDA
applications are system components that communicate entirely through HTTP/REST
interfaces.InstallationTo install LD4Apps:pipinstallld4appsThe LDA framework requires a running back-end database for storing application data.
The default storage implementation uses MongoDB, so the fastest way to get started is
to simply go to theMongoDB download pageand download
the appropriate version for your OS.Once MongoDB has downloaded, execute the following commands:cd<mongodb-installation-directory>/binmongodAt this point, MonoDB should be running and listening on its default host and port (localhost:27017).To configure LDA with the MongoDB server, 3 environment variables also need to be set:MONGODB_DB_HOST - hostname of the MONGODB server to useMONGODB_DB_PORT - the MONGDOB server portAPP_NAME - the name of you application, which is used as the DB name where the resources will be storedExampleYou can create a Linked-Data resource using theld4apps.ldamodule like this:>>>importos>>>os.environ['MONGODB_DB_HOST']='localhost'>>>os.environ['MONGODB_DB_PORT']='27017'>>>os.environ['APP_NAME']='teststore'>>>fromld4appsimportlda>>>foo_container_environ={'HTTP_HOST':'localhost','PATH_INFO':'/tst/foo','QUERY_STRING':''}>>>new_foo_resource={'rdfs_label':'my foo','rdf_type':'http://example.org#Foo'}>>>body,status,headers=lda.create_document(foo_container_environ,new_foo_resource,'in_foo_container')INFO:ld4apps.mongodbstorage.operation_primitives:createddocumenthttp://localhost/tst/foo/4.1>>>status201>>>importjson>>>printjson.dumps(body,indent=4){"ce_owner":"http://localhost/unknown_user/da36bb01-0d1c-438a-9d00-9940085aae20","rdfs_label":"my foo","in_foo_container":"http://localhost/tst/foo","ce_lastModified":"2015-04-28T18:30:40.993176+00:00","dc_created":"2015-04-28T18:30:40.993176+00:00","ac_resource-group":"http://localhost/","_subject":"http://localhost/tst/foo/3.2","ce_revision":"0","ce_lastModifiedBy":"http://localhost/unknown_user/da36bb01-0d1c-438a-9d00-9940085aae20","dc_creator":"http://localhost/unknown_user/da36bb01-0d1c-438a-9d00-9940085aae20","rdf_type":"http://example.org#Foo"}An example using ld4apps along withFlaskto implement a simple “todo list” web-server
can be found here:https://github.com/ld4apps/lda-examples/tree/ld4apps/todo-flask.DocumentationDocumentation is available athttp://ld4apps.github.io/.
Package: lda11
LDA11 - yet another collapsed gibbs sampler for python.FeaturesSupport parallelized sampler proposed inDistributed Inference for Latent Dirichlet Allocation.ImplementCGS_p estimatorfor more precise point estimate of topic-word distribution.ImplementLabelled LDAAble to obtain per-word topic frequency.The implementaion relies onEigenfor faster array multiplication andpybind11for simple binding.InstallationYou can install the wheel from pypi:pip install lda11For x64 architecture, the above wheel is built using AVX.
If it is not convenient for you, try e.g.CFLAGS="-march=native" pip install git+https://github.com/tohtsky/lda11
Package: lda-classification
lda_classifcationInstantly train an LDA model with a scikit-learn compatible wrapper around gensim's LDA model.Preprocess Your DocumentsTrain an LDAEvaluate Your LDA ModelExtract Document VectorsSelect the Most Informative FeaturesClassify Your DocumentsAll in a few lines of code, completely compatible withsklearn's Transformer API.Installation:If you want to install via Pypi use the following command:pip install lda_classificationIf you want to install from the sourcefile:git clone https://github.com/FeryET/lda_classification.git
cd lda_classification/
python setup.py installRequirements:gensim == 3.8.0
matplotlib == 3.1.2
numpy == 1.19.1
setuptools~=49.6.0
spacy == 2.3.1
tqdm == 4.48.2
scikit-learn~=0.23.1
tomotopy~=0.9.1Optional:If you want to automate the feature selection using this package you can also installxgboostto use the util class.xgboost == 1.1.1 (Optional)Example:fromlda_classification.modelimportGensimLDAVectorizerfromlda_classification.preprocessimportSpacyCleanerfromlda_classification.utilsimportXGBoostFeatureSelector# docs, labels = FETCH YOUR DATASET# y = ENCODED_LABELSdocs=SpacyCleaner().transform(docs)X=GensimLDAVectorizer(200,return_dense=False).fit_transform(docs)X_transform=XGBoostFeatureSelector().fit_transform(X,y)There is also adataloaderclass and aBaseDataclass in
order to automate reading your data files from disk. ExtendBaseDataand implement the abstractmethods in the subclass and
feed it toDataReaderto simplify fetching your dataset.
Package: lda-over-time
Lda Over TimeTable of ContentsAboutInstallationTutorialLicenseAboutLdaOverTime is a framework that brings an easier way of doing Topic Modeling
Analysis Over Time and get visualization of results.In brief, Topic Modeling is a technique that finds topics that each document
from a collection covers. And, by addind the time in this equation, we can
study how much and why one certain topic is more or less discussed in a
time slice.Installationpip install lda-over-timeTutorialYou can check out the library's tutorial and small example of usage atnotebooks/tutorial.ipynb.Licenselda-over-timeis distributed under the terms of theLGPL3.
Package: ldap
ldapon PyPIThis dummy project is not installable.
You probably wantpython-ldapinstead.python-ldapThe widely usedpython-ldapproject provides
an importable module namedldap.This goes against the convention that PyPI distribution names should
match the module names.
But, python-ldap pre-dates wide use of that convention, and the issue
is hard to fix now.Please installpython-ldapto get the LDAP bindings.ldap 1.0Theldapname on PyPI was used for an unrelated collection of
LDAP-related utilities, which is not as popular, and confused users who
installldapto get theldapmodule.The project is no longer developed.
It is archived as1.0.xreleases on PyPI, and onGitHub.Why we don't fix this transparentlyThis could have been a placeholder  package that depends onpython-ldap,
saving you the trouble of reading this message.However,piphas troublewith differently-named packages that provide the same module.Please: Don't install packages blindlyWhen you see the exception:ModuleNotFoundError: No module named 'foo'… please research the actual requirements instead of going directly forpip install foo.
The project (distribution) name may differ from the module(s) it
provides.
Package: ldap0
Module ldap0Module packageldap0provides an object-oriented API to access LDAP
directory servers from Python programs. Mainly it wraps the OpenLDAP 2.x
libs for that purpose.Additionally the package contains some Python modules for:parsing and producing LDIFhandling LDAP URLsparse and handle LDAPv3 subschemaLDAPv3 extended operations and controlsautomatic tests with OpenLDAP serverInstalling this module is required for running this software:web2ldapÆ-DIROATH-LDAPslapdcheckFurther notes:ldap0meansldapreset.Only works with Python 3.6 or newer!This module is of no general use!Don't use it for your own project!
The API may change at any time without further notice!You have been warned!
Package: ldap2jira
python-ldap2jiraSet of utilities for finding jira accounts with LDAP check and optional file map.Pypi Packagehttps://pypi.org/project/ldap2jira/Docshttps://python-ldap2jira.readthedocs.io/UsageInstall package from pypipip install ldap2jiraIn pythonfrom ldap2jira import LDAP2JiraUserMap

l2j = LDAP2JiraUserMap(
    jira_url='https://yourjiraserver',
    jira_user='yourjirauser',
    jira_password='yourpassword',
    ldap_url='ldap://yourldapserver,
    ldap_base='ou=users,dc=your,dc=base',
    ldap_query_fields_username=['uid'],
    ldap_fields_username=['uid'],
    ldap_fields_mail=['mail'],
    ldap_fields_name=['cn'],
    ldap_fields_jira_search=[
        'mail', 'uid', 'cn'],
    email_domain='yourdomain.org'
)

l2j.find_jira_accounts(['usertofind', 'user2tofind'])
Package: ldap2pg
Swiss-army knife to synchronize Postgres roles and privileges from YAML or LDAP.Postgres is able to check password against an entreprise directory using the
LDAP protocol out of the box. ldap2pg automates the creation, update and
removal of PostgreSQL roles and users based on entreprise organigram described
in the directory.Managing roles is close to managing privileges as you expect roles to have
proper default privileges. ldap2pg can grant and revoke privileges too.FeaturesReads settings from an expressive YAML config file.Creates, alters and drops PostgreSQL roles from LDAP searches.Creates static roles from YAML to complete LDAP entries.Manages role members (aliasgroups).Grants or revokes privileges statically or from LDAP entries.Dry run, check mode.Logs LDAP searches asldapsearch(1)commands.LogseverySQL query.Here is a sample configuration and execution:$ cat ldap2pg.yml
- role:
    name: ldap_roles
    options: NOLOGIN
- ldapsearch:
    base: ou=people,dc=ldap,dc=ldap2pg,dc=docker
    filter: "(objectClass=organizationalPerson)"
  role:
    name: '{cn}'
    options: LOGIN
    parent: ldap_roles
$ ldap2pg --real
Starting ldap2pg 5.7.
Using .../ldap2pg.yml.
Running in real mode.
Inspecting roles in Postgres cluster...
Querying LDAP ou=people,dc=ldap,dc=lda... (objectClass...
Create domitille.
Add missing ldap_roles members.
Delete spurious ldap_roles members.
Update options of albert.
Reassign oscar objects and purge ACL on postgres.
Reassign oscar objects and purge ACL on template1.
Drop oscar.
Synchronization complete.
$Installationldap2pg requires Python 2.6+ or 3+, pyyaml, python-ldap and psycopg2.The universal installation method is to download from PyPI using pip. Other
methods and more details are described in this documentation.# apt install -y libldap2-dev libsasl2-dev
# pip install ldap2pg psycopg2-binaryldap2pgis licensed under PostgreSQLlicense.ldap2pgis available with
the help of wonderful people, jump tocontributorslist to see them.ldap2pgrequiresa configuration file calledldap2pg.yaml. The [dumb
but testedldap2pg.yml](https://github.com/dalibo/ldap2pg/blob/master/ldap2pg.yml) is a
good way to start.# curl -LOhttps://github.com/dalibo/ldap2pg/raw/master/ldap2pg.yml# editor ldap2pg.ymlFinally, it’s up to you to useldap2pgin a crontab or a playbook. Have fun!ldap2pgis reported to work withOpenLDAP,FreeIPA, Oracle Internet
Directory and Microsoft Active Directory.SupportIf you need support and you didn’t found it indocumentation, just drop a
question in aGitHub issue!
French accepted. Don’t miss thecookbook. You’re welcome!
Package: ldap3-orm
ldap3-orm is an object-relational mapper for LDAP data based on theldap3 projectHome PageProject home page ishttps://github.com/cfelder/ldap3-ormDocumentationDocumentation is available athttp://code.bsm-felder.de/doc/ldap3-ormLicenseThe ldap3-orm library is open source software released under theLGPL-3.0+ license(http://www.gnu.org/licenses/lgpl-3.0.html).PEP8 Complianceldap3 is PEP8 compliant.DownloadPackage download is available athttps://pypi.python.org/pypi/ldap3-orm.Installldap-orm can be installed from the Python Package Index usingpiporpip3.$ pip3 install ldap3-ormThis will install ldap3-orm and its minimal requirements necessary for
importing the package and using it in your own projects. For installing
ldap3-orm with all possible requirements the following command can be used.$ pip3 install ldap3-orm[all]Git repositoryYou can download the latest source athttps://github.com/cfelder/ldap3-orm
Package: ldapcherry
LdapCherryNice and simple application to manage users and groups in multiple directory services.Doc:LdapCherry documentation on ReadTheDocDev:LdapCherry source code on GitHubPyPI:LdapCherry package on PypiLicense:MITAuthor:Pierre-Francois Carpentier - copyright © 2016DemoA demo is accessible here:https://ldapcherry.kakwalab.ovhThe credentials are:as administrator: admin/adminas user: user/userPlease take note that it’s not possible to modify/delete the ‘admin’ and ‘user’ users.Also take note that the service will be reseted once per day.PresentationLdapCherry is a CherryPY application to manage users and groups in multiple directory services.Its main features are:manage multiple directories/databases backends in an unified wayroles management (as in “groups of groups”)autofill formspassword policyself modification of some selected fields by normal (non administrator) usersnice bootstrap interfacemodular through pluggable authentication, password policy and backend modulesLdapCherry is not limited to ldap, it can handle virtually any user backend (ex: SQL database, htpasswd file, etc)
through the proper plugin (provided that it is implemented ^^).LdapCherry also aims to be as simple as possible to deploy: no crazy dependencies,
few configuration files, extensive debug logs and full documentation.The default backend plugins permit to manage Ldap and Active Directory.ScreenshotsScreenshots.Try out# clone the repository$gitclonehttps://github.com/kakwa/ldapcherry&&cdldapcherry# change the directory where to put the configuration (default: /etc)$exportSYSCONFDIR=/etc# change the directory where to put the resource (default: /usr/share)$exportDATAROOTDIR=/usr/share/# install ldapcherry$pythonsetup.py# edit configuration files$vi/etc/ldapcherry/ldapcherry.ini$vi/etc/ldapcherry/roles.yml$vi/etc/ldapcherry/attributes.yml# launch ldapcherry$ldapcherryd-c/etc/ldapcherry/ldapcherry.ini-DLicenseLdapCherry is published under the MIT Public License.Discussion / Help / UpdatesIRC:Freenode#ldapcherrychannelBugtracker:Github
Package: ldaphelper
ldaphelperWanna try to make it a little easierfromldaphelperimportLdapConnection(),Useruser='cn=directory manager'password='amazingpassword'con=LdapConnection(user,password)ldp_user=User(con)user={"uuid":"johndoe","password":"strongpassword,"mail":"john.doe@ldaphelper.org","givenName":"John","sn":"Doe"}added_user=ldp_user.add_user(user)
Package: ldap-hopper
LDAP-Hopperldap_hopperis a smallPython3package that allows you to easily navigate and manipulate an LDAP directory-information-tree(DIT).
It neatly wraps around the standardldappackage and takes away all the nasty bits and pieces of boiler-plating, while making your code more readable.Installationpip install ldap_hopperUsage#!/usr/bin/env python3fromldap_hopperimportConfig,Cursor# define an access configurationconfig=Config(server='ldap://localhost',dn='dc=example.dc=com',#    bind_dn='',#    bind_pw='',#    use_tls=True,)# creating a cursorroot=Cursor(config)print(root.attrs)# traversal via standard generators[childforchildinroot.children][subforsubinroot.subtree]# adding a child nodedn='ou=crew,dc=example,dc=com'attrs={'objectClass':['organizationalUnit'],'ou':['crew'],}cursor=root.add(dn,attrs)# searching defaults to ldap.SCOPE_SUBTREE[resultforresultinroot.search('ou=crew')]fromldap_hopperimportScope[rforrinroot.search('objectClass=*',Scope.onelevel)]# manipulating attributescursor.attrs['description']='Lorem ipsum...'delcursor.attrs['desciption']# deleting an entire objectcursor.delete()Developmentgit clone github.com:baccenfutter/ldap_hopper.git
cd ldap_hopper
pipenv install --devResourcesSource:https://github.com/baccenfutter/ldap_hopperPyPi  :https://pypi.python.org/pypi/ldap_hopper/
Package: ldapKIT
LDAP User Script ToolkitA collection of python scripts that act as a wrapper/cli for the python-ldap library. There is an overall config file config.yml. The scripts have the following functionalities:add/delete LDAP accounts,create/archive user directories (and set quotas) belonging to these accounts on all fileservers according to the settings in the config.yml,change email addresses in LDAP, GitLab and mailing list subscriptionsreset passwordscreate/remove groups in ldapadd/remove users from LDAP groupsAll scripts provide--help,--verboseand--dryrunflags.Installpip install ldapKITUser add/deleteTo add/delete users, you can use the scripts:particleldapuseraddandparticleldapuserdel -–user NAME.There is also the functionality to search for users that are inactive forndays (inactive means: last password change older thanmdays) and delete them withparticleldapuserdel –-cleanup.The userdel script does not only remove the ldap user but is also able to run post-deletion tasks via ansible e.g. to backup user directories.Group add/delete/modifyThis is done via the toolparticleldapgroup. Usage:# particleldapgroup --helpusage:particleldapgroup[-h][--verbose][--dryrun]{create,delete,adduser,deluser,cleanup}...

positionalarguments:{create,delete,adduser,deluser,cleanup}createcreatenewgroupdeletedeletegroupadduseradduserstogroupdeluserremoveusersfromgroupcleanupremovenon-existantusersfromgroup

optionalarguments:-h,--helpshowthishelpmessageandexit--verbose,-vaddmoreouput--dryrun,-ddon'twriteanythingChanging E-Mail AddressesThere is the scriptparticleldapchangeemailwhich changes the email of an user in its:LDAP account,GitLab account (which somehow does not update its database when an ldap account changes its email)and removes/adds its old/new email to a configured mailing list.Example configurationSee theconfig.ymlfor an example configuration which uses the full functionality. Also see theuserdir.ymlwhich is an ansible playbook invoked byparticleldapuser{add,del}to create/archive user dirs on foregin file servers (set in the config.yml).
Package: ldapmgk
Helper for managing an LDAP directory on CLIPurposeldapmgk is a simple command line program that manages an LDAP directory. You
can use it to easily add or remove users and groups, reset passwords and
add or remove users to groups.RequirementsThis program requires openldap development files for using thepython-ldapmodule. It’ll be needed wheh installing throughpip.InstallationUsing pip, it should be easy:$ pip install ldapmgkIf you’re not using pip or got it from the repository, use the following
command:$ pip install -e .We recommend using virtualenv to setup a self-contained app directory. In this
case, you should use:$ virtualenv env
$ source env/bin/activate
$ pip install -e .If you want to see which libraries this application uses, please check therequirements.txtfile.UsageDefault paths:Configuration:/etc/ldapmgk/ldapmgk.cfgTo run it, activate virtualenv first:$ source env/bin/activate
$ ldapmgk -h
Package: ldap-notify
ldap-notifysearches users in an LDAP directory whose login or password expires in a certain number of days. These users are notified with a customizable email. The time intervals for the notifications and the email templates can be freely defined. By using a custom LDAP attribute the last notification is stored in the directory such that users are only notified once per rule. Moreover, this mechanism allows running the tool (e.g. via cron) on multiple machine with a certain time delta in order to implement high availabiliy.
Package: ldapom
# LDAPomLDAPom is a pythonic LDAP to Python object mapper. It should work with Python 2.7 and all versions of Python 3.## TestingBecause LDAPom uses a real LDAP server for testing, OpenLDAP is required to be
installed (i.e.slapdandslapaddhave to be in$PATH).# Install development dependencies
pip install -r dev-requirements.txt
# Run the tests
python tests.py## A note about Unicode strings in Python 2LDAPom is source-code compatible with both Python 2 and Python 3. However,
LDAPom expects unicode strings to be passed to it whenever a string is
required.For Python 2, this means that you should use theunicodetype forstr-type
arguments and thestr/bytestype forbytes-type arguments.In Python 3, everything is exactly as you would expect.strfor strings,bytesfor binary data. Simple, really.## LicenseLDAPom is licensed under the MIT license. For more information, see theCOPYINGfile.
Package: ldapom-model
LDAPOM ModelProvides base class LDAPModel create a model usingLDAPOM.Installationpip install ldapom-modelExamplefrom ldapom-model import LDAPModel, LDAPAttr

class Person(LDAPModel):
    _class = 'inetOrgPerson'
    _class_attrs = {'cn': LDAPAttr('cn'),
                    'o': LDAPAttr('o'),
                    'mail': LDAPAttr('mail'),
                    'lastname': LDAPAttr('sn'),
                    'firstname': LDAPAttr('givenName'),
                    'phone': LDAPAttr('telephoneNumber'),
                    'address': LDAPAttr('postalAddress')}
    _rdn = 'cn'

    def __str__(self):
        return self.name

    @property
    def name(self):
        return ' '.join([self.givenName, self.sn]) if self.givenName else self.snAnd then :from ldapom import LDAPConnection

conn = LDAPConnection(uri="ldap://ldap.example.net", base="dc=example,dc=net", bind_dn="cn=root,dc=example,dc=net", bind_password="rootpassword")

toto = Person.retrieve(conn, "toto")
toto.mail = "toto@example.net"
toto.firstname = "foo"
toto.save()

persons = Person.search(conn)LicenceThis code is underWTFPL. Just do what the fuck you want with it.